Attachment #79246 for bug #146852

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 146852
Collapse All | Expand All

Lines 61-67 Link Here

(-)a/ant.freeform/nbproject/project.xml (-1 / +1 lines)
61	<compile-dependency/>	61	<compile-dependency/>
62	<run-dependency>	62	<run-dependency>
63	<release-version>1</release-version>	63	<release-version>1</release-version>
64	<specification-version>1.30</specification-version>	64	<specification-version>1.31</specification-version>
65	</run-dependency>	65	</run-dependency>
66	</dependency>	66	</dependency>
67	<dependency>	67	<dependency>




    }
    
    private Sources initSources() {
        SourcesHelper h = new SourcesHelper(project, project.helper(), project.evaluator());
        Element genldata = project.getPrimaryConfigurationData();
        Element foldersE = Util.findElement(genldata, "folders", FreeformProjectType.NS_GENERAL); // NOI18N
        if (foldersE != null) {

                }
            }
        }
        h.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
            public void run() {
                h.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
            }
        });
        return h.createSources();
    }
    

Lines 212-218 Link Here

(-)a/apisupport.project/nbproject/project.xml (-1 / +1 lines)
212	<compile-dependency/>	212	<compile-dependency/>
213	<run-dependency>	213	<run-dependency>
214	<release-version>1</release-version>	214	<release-version>1</release-version>
215	<specification-version>1.30</specification-version>	215	<specification-version>1.31</specification-version>
216	</run-dependency>	216	</run-dependency>
217	</dependency>	217	</dependency>
218	<dependency>	218	<dependency>




import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.classpath.GlobalPathRegistry;
import org.netbeans.api.java.project.JavaProjectConstants;

        }
        FileBuiltQueryImplementation fileBuilt = helper.createGlobFileBuiltQuery(
                eval,from.toArray(new String[0]), to.toArray(new String[0]));
        SourcesHelper sourcesHelper = new SourcesHelper(this, helper, eval);
        // Temp build dir is always internal; NBM build products go elsewhere, but
        // difficult to predict statically exactly what they are!
        // XXX would be good to mark at least the module JAR as owned by this project

                    /* XXX should schema incl. display name? */entry.getKey().getNameExt(), null, null);
        }
        // #56457: support external source roots too.
        sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
            public void run() {
                sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
            }
        });
        lookup = createLookup(new Info(), aux, helper, fileBuilt, sourcesHelper);
    }


Lines 156-162 Link Here

(-)a/bpel.project/nbproject/project.xml (-1 / +1 lines)
156	<compile-dependency/>	156	<compile-dependency/>
157	<run-dependency>	157	<run-dependency>
158	<release-version>1</release-version>	158	<release-version>1</release-version>
159	<specification-version>1.30</specification-version>	159	<specification-version>1.31</specification-version>
160	</run-dependency>	160	</run-dependency>
161	</dependency>	161	</dependency>
162	<dependency>	162	<dependency>




import java.util.Set;
import java.util.logging.Logger;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectManager;
import org.netbeans.api.project.ant.AntArtifact;
import org.openide.cookies.SaveCookie;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataObjectNotFoundException;
import org.openide.filesystems.FileUtil;
import org.openide.filesystems.FileChangeListener;
import org.openide.filesystems.FileEvent;

import org.openide.filesystems.FileAttributeEvent;
import org.openide.filesystems.FileLock;
import org.netbeans.modules.compapp.projects.base.spi.JbiArtifactProvider;
import org.netbeans.modules.compapp.projects.base.ui.IcanproCustomizerProvider;
import org.netbeans.modules.compapp.projects.base.ui.customizer.IcanproProjectProperties;
import org.netbeans.modules.bpel.model.api.support.Utils;
import org.netbeans.api.project.ProjectInformation;

import org.openide.util.ImageUtilities;
import org.openide.util.Lookup;
import org.openide.util.Mutex;
import org.openide.util.Utilities;
import org.openide.util.lookup.Lookups;
import org.netbeans.spi.java.project.support.ui.BrokenReferencesSupport;
import org.netbeans.spi.project.AuxiliaryConfiguration;

                new String[] {"${src.dir}/*.java"}, // NOI18N
                new String[] {"${build.classes.dir}/*.class"} // NOI18N
        );
        SourcesHelper sourcesHelper = new SourcesHelper(this, helper, evaluator());
        String webModuleLabel = org.openide.util.NbBundle.getMessage(ProjectLogicalViewProvider.class, "LBL_Node_EJBModule"); //NOI18N
        String srcJavaLabel = org.openide.util.NbBundle.getMessage(ProjectLogicalViewProvider.class, "LBL_Node_Sources"); //NOI18N
        

                org.netbeans.modules.xml.catalogsupport.ProjectConstants.SOURCES_TYPE_XML,
                srcJavaLabel, null, null);
        
        sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
            public void run() {
                sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
            }
        });
        return Lookups.fixed(new Object[] {
            new Info(),
            aux,

Lines 81-87 Link Here

(-)a/cnd.makeproject/nbproject/project.xml (-1 / +1 lines)
81	<compile-dependency/>	81	<compile-dependency/>
82	<run-dependency>	82	<run-dependency>
83	<release-version>1</release-version>	83	<release-version>1</release-version>
84	<specification-version>1.12.1</specification-version>	84	<specification-version>1.31</specification-version>
85	</run-dependency>	85	</run-dependency>
86	</dependency>	86	</dependency>
87	<dependency>	87	<dependency>




import java.util.Set;
import javax.swing.event.ChangeListener;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.ProjectManager;
import org.netbeans.api.project.SourceGroup;
import org.netbeans.api.project.Sources;
import org.netbeans.modules.cnd.api.utils.IpeUtils;

    }

    private Sources initSources() {
        SourcesHelper h = new SourcesHelper(project, helper, project.evaluator());
        ConfigurationDescriptorProvider pdp = project.getLookup().lookup(ConfigurationDescriptorProvider.class);
        ConfigurationDescriptor pd = pdp.getConfigurationDescriptor(!MakeProjectConfigurationProvider.ASYNC_LOAD);
        if (pd != null) {

                h.addTypedSourceRoot(name, "generic", displayName, null, null); // NOI18N
            }
        }
        h.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);

            public void run() {
                h.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
            }
        });
        return h.createSources();
    }


Lines 101-107 Link Here

(-)a/compapp.projects.base/nbproject/project.xml (-1 / +1 lines)
101	<compile-dependency/>	101	<compile-dependency/>
102	<run-dependency>	102	<run-dependency>
103	<release-version>1</release-version>	103	<release-version>1</release-version>
104	<specification-version>1.30</specification-version>	104	<specification-version>1.31</specification-version>
105	</run-dependency>	105	</run-dependency>
106	</dependency>	106	</dependency>
107	<dependency>	107	<dependency>




import java.nio.charset.Charset;
import java.nio.charset.IllegalCharsetNameException;
import java.nio.charset.UnsupportedCharsetException;
import java.util.*;
import java.util.logging.Logger;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectManager;

import org.openide.util.ImageUtilities;
import org.openide.util.Lookup;
import org.openide.util.Mutex;
import org.openide.util.Utilities;
import org.openide.util.lookup.Lookups;
import org.netbeans.spi.project.AuxiliaryConfiguration;
import org.netbeans.spi.project.support.ant.AntBasedProjectRegistration;

            new String[] {"${src.dir}/*.java"}, // NOI18N
            new String[] {"${build.classes.dir}/*.class"} // NOI18N
        );
        SourcesHelper sourcesHelper = new SourcesHelper(this, helper, evaluator());
        String webModuleLabel = org.openide.util.NbBundle.getMessage(IcanproCustomizerProvider.class, "LBL_Node_EJBModule"); //NOI18N
        String srcJavaLabel = org.openide.util.NbBundle.getMessage(IcanproCustomizerProvider.class, "LBL_Node_Sources"); //NOI18N



        sourcesHelper.addTypedSourceRoot("${"+IcanproProjectProperties.SRC_DIR+"}", SOURCES_TYPE_ICANPRO, srcJavaLabel, /*XXX*/null, null);
        // sourcesHelper.addTypedSourceRoot("${"+IcanproProjectProperties.SRC_DIR+"}", JavaProjectConstants.SOURCES_TYPE_JAVA, srcJavaLabel, /*XXX*/null, null);
        sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
            public void run() {
                sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
            }
        });
        return Lookups.fixed(new Object[] {
            new Info(),
            aux,




                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.libs.httpunit</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <release-version>1</release-version>
                        <specification-version>1.10</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.libs.jaxb</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <release-version>1</release-version>
                        <specification-version>1.3</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.libs.xerces</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>

                    <compile-dependency/>
                    <run-dependency>
                        <release-version>1</release-version>
                        <specification-version>1.31</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>

                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.libs.jaxb</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <release-version>1</release-version>
                        <specification-version>1.3</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.modules.websvc.jaxws21</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>

                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.libs.httpunit</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <release-version>1</release-version>
                        <specification-version>1.10</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.soa.libs.jbiadmincommon</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>




import org.openide.util.ImageUtilities;
import org.openide.util.Lookup;
import org.openide.util.Mutex;
import org.openide.util.Utilities;
import org.openide.util.lookup.Lookups;
import org.openide.windows.TopComponent;
import org.w3c.dom.Element;

import java.util.*;
import java.util.logging.Logger;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.SwingUtilities;
import org.netbeans.api.queries.FileEncodingQuery;
import org.netbeans.modules.compapp.projects.jbi.ComponentInfoGenerator;
import org.netbeans.modules.compapp.projects.jbi.queries.JbiProjectEncodingQueryImpl;
import org.netbeans.modules.sun.manager.jbi.management.model.ComponentInformationParser;
import org.netbeans.modules.sun.manager.jbi.management.model.JBIComponentDocument;
import org.netbeans.modules.sun.manager.jbi.management.model.JBIComponentStatus;
import org.openide.filesystems.FileChangeAdapter;
import org.openide.filesystems.FileChangeListener;

                helper.getStandardPropertyEvaluator(), new String[] {"${src.dir}/*.java"}, // NOI18N
                new String[] {"${build.classes.dir}/*.class"} // NOI18N
        );
        SourcesHelper sourcesHelper = new SourcesHelper(this, helper, evaluator());
        String webModuleLabel = org.openide.util.NbBundle.getMessage(
                JbiCustomizerProvider.class, "LBL_Node_EJBModule" // NOI18N
                );

                srcJavaLabel, /*XXX*/
                null, null
                );
        sourcesHelper.registerExternalRoots(
                FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT
                );
                sourcesHelper.registerExternalRoots(
                        FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT
                        );
            }
        }
        );
        
        casaFileListener = new FileChangeAdapter() {
            @Override

Lines 117-123 Link Here

(-)a/etl.project/nbproject/project.xml (-1 / +1 lines)
117	<compile-dependency/>	117	<compile-dependency/>
118	<run-dependency>	118	<run-dependency>
119	<release-version>1</release-version>	119	<release-version>1</release-version>
120	<specification-version>1.11.1</specification-version>	120	<specification-version>1.31</specification-version>
121	</run-dependency>	121	</run-dependency>
122	</dependency>	122	</dependency>
123	<dependency>	123	<dependency>




import java.io.IOException;
import java.io.File;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import net.java.hulp.i18n.Logger;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.project.FileOwnerQuery;

import org.openide.util.ImageUtilities;
import org.openide.util.Lookup;
import org.openide.util.Mutex;
import org.openide.util.Utilities;
import org.openide.util.lookup.Lookups;
import org.netbeans.modules.compapp.projects.base.spi.JbiArtifactProvider;
import org.netbeans.modules.etl.project.ui.EtlproLogicalViewProvider;

                new String[]{"${src.dir}/*.java"}, // NOI18N
                new String[]{"${build.classes.dir}/*.class"} // NOI18N
                );
        SourcesHelper sourcesHelper = new SourcesHelper(this, helper, evaluator());
        /*String nbBundle1 = mLoc.t("BUND711: EJB Module");
        String nbBundle2 = mLoc.t("BUND712: Source Packages");
        String webModuleLabel = nbBundle1.substring(15); //NOI18N


        sourcesHelper.addTypedSourceRoot("${" + IcanproProjectProperties.SRC_DIR + "}", SOURCES_TYPE_ICANPRO, srcJavaLabel, /*XXX*/ null, null);
        sourcesHelper.addTypedSourceRoot("${" + IcanproProjectProperties.SRC_DIR + "}", JavaProjectConstants.SOURCES_TYPE_JAVA, srcJavaLabel, /*XXX*/ null, null);
        sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);

            public void run() {
                sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
            }
        });
        return Lookups.fixed(new Object[]{
            new Info(),
            aux,

Lines 108-114 Link Here

(-)a/iep.project/nbproject/project.xml (-1 / +1 lines)
108	<compile-dependency/>	108	<compile-dependency/>
109	<run-dependency>	109	<run-dependency>
110	<release-version>1</release-version>	110	<release-version>1</release-version>
111	<specification-version>1.12.1</specification-version>	111	<specification-version>1.31</specification-version>
112	</run-dependency>	112	</run-dependency>
113	</dependency>	113	</dependency>
114	<dependency>	114	<dependency>




import java.io.File;
import java.io.IOException;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import org.netbeans.modules.xml.catalogsupport.ProjectConstants;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectInformation;
import org.netbeans.api.project.ProjectManager;
import org.netbeans.api.project.ant.AntArtifact;
import org.netbeans.modules.iep.project.ui.customizer.IepProjectCustomizerProvider;
import org.netbeans.spi.java.project.support.ui.BrokenReferencesSupport;
import org.netbeans.spi.project.AuxiliaryConfiguration;
import org.netbeans.spi.project.SubprojectProvider;

import org.openide.util.ImageUtilities;
import org.openide.util.Lookup;
import org.openide.util.Mutex;
import org.openide.util.Utilities;
import org.openide.util.lookup.Lookups;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

            new String[] {"${src.dir}/*.java"}, // NOI18N
            new String[] {"${build.classes.dir}/*.class"} // NOI18N
        );
        SourcesHelper sourcesHelper = new SourcesHelper(this, helper, evaluator());
        String webModuleLabel = org.openide.util.NbBundle.getMessage(IcanproCustomizerProvider.class, "LBL_Node_EJBModule"); //NOI18N
        String srcJavaLabel = org.openide.util.NbBundle.getMessage(IepProjectLogicalViewProvider.class, "LBL_Node_Sources"); //NOI18N


        sourcesHelper.addTypedSourceRoot("${"+IcanproProjectProperties.SRC_DIR+"}", 
                org.netbeans.modules.xml.catalogsupport.ProjectConstants.SOURCES_TYPE_XML,
                srcJavaLabel, /*XXX*/null, null);
        sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
            public void run() {
                sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
            }
        });
        return Lookups.fixed(new Object[] {
            new Info(),
            aux,

Lines 236-242 Link Here

(-)a/j2ee.clientproject/nbproject/project.xml (-1 / +1 lines)
236	<compile-dependency/>	236	<compile-dependency/>
237	<run-dependency>	237	<run-dependency>
238	<release-version>1</release-version>	238	<release-version>1</release-version>
239	<specification-version>1.30</specification-version>	239	<specification-version>1.31</specification-version>
240	</run-dependency>	240	</run-dependency>
241	</dependency>	241	</dependency>
242	<dependency>	242	<dependency>




import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.classpath.GlobalPathRegistry;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectInformation;
import org.netbeans.api.project.ProjectManager;

import org.netbeans.spi.project.support.ant.PropertyEvaluator;
import org.netbeans.spi.project.support.ant.PropertyUtils;
import org.netbeans.spi.project.support.ant.ReferenceHelper;
import org.netbeans.spi.project.support.ant.SourcesHelper;
import org.netbeans.spi.project.ui.PrivilegedTemplates;
import org.netbeans.spi.project.ui.ProjectOpenedHook;
import org.netbeans.spi.project.ui.RecommendedTemplates;

    
    private Lookup createLookup(AuxiliaryConfiguration aux, ClassPathProviderImpl cpProvider) {
        SubprojectProvider spp = refHelper.createSubprojectProvider();

        final SourcesHelper sourcesHelper = new SourcesHelper(helper, evaluator());
        String configFilesLabel = NbBundle.getMessage(AppClientLogicalViewProvider.class, "LBL_Node_ConfFiles"); //NOI18N
        
        //sourcesHelper.addPrincipalSourceRoot("${"+AppClientProjectProperties.SOURCE_ROOT+"}", ejbModuleLabel, /*XXX*/null, null);
        sourcesHelper.addPrincipalSourceRoot("${"+AppClientProjectProperties.META_INF+"}", configFilesLabel, /*XXX*/null, null); // NOI18N
        
        ProjectManager.mutex().postWriteRequest(new Runnable() {
            public void run() {
                sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
            }
        });
        FileEncodingQueryImplementation encodingQuery = QuerySupport.createFileEncodingQuery(evaluator(), AppClientProjectProperties.SOURCE_ENCODING);
        Lookup base = Lookups.fixed(new Object[] {
            new Info(),

            UILookupMergerSupport.createProjectOpenHookMerger(new ProjectOpenedHookImpl()),
            QuerySupport.createUnitTestForSourceQuery(getSourceRoots(),getTestSourceRoots()),
            QuerySupport.createSourceLevelQuery(evaluator()),
            new AppClientSources(this, helper, evaluator(), getSourceRoots(), getTestSourceRoots()),
            QuerySupport.createSharabilityQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots(),
                    AppClientProjectProperties.META_INF),
            QuerySupport.createFileBuiltQuery(helper,  evaluator(), getSourceRoots(), getTestSourceRoots()),




import org.netbeans.api.project.ProjectManager;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.project.Project;
import org.netbeans.modules.j2ee.clientproject.ui.AppClientLogicalViewProvider;
import org.netbeans.modules.java.api.common.SourceRoots;
import org.netbeans.modules.java.api.common.project.ProjectProperties;

    private static final String BUILD_DIR_PROP = "${" + AppClientProjectProperties.BUILD_DIR + "}";    //NOI18N
    private static final String DIST_DIR_PROP = "${" + AppClientProjectProperties.DIST_DIR + "}";    //NOI18N

    private final Project project;
    private final AntProjectHelper helper;
    private final PropertyEvaluator evaluator;
    private final SourceRoots sourceRoots;
    private final SourceRoots testRoots;
    private SourcesHelper sourcesHelper;
    private Sources delegate;
    /**
     * Flag to forbid multiple invocation of {@link SourcesHelper#registerExternalRoots} 
     **/
    private boolean externalRootsRegistered;    
    private final List<ChangeListener> listeners = new ArrayList<ChangeListener>();

    AppClientSources(Project project, AntProjectHelper helper, PropertyEvaluator evaluator,
                SourceRoots sourceRoots, SourceRoots testRoots) {
        this.project = project;
        this.helper = helper;
        this.evaluator = evaluator;
        this.sourceRoots = sourceRoots;

    }

    private Sources initSources() {        
        sourcesHelper = new SourcesHelper(project, helper, evaluator);
        register(sourceRoots);
        register(testRoots);
        

        sourcesHelper.addNonSourceRoot(BUILD_DIR_PROP);
        sourcesHelper.addNonSourceRoot(DIST_DIR_PROP);
        
        sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
        ProjectManager.mutex().postWriteRequest(new Runnable() {
            public void run() {
                if (!externalRootsRegistered) {
                    sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
                    externalRootsRegistered = true;
                }
            }
        });
        return sourcesHelper.createSources();
    }


Lines 210-216 Link Here

(-)a/j2ee.earproject/nbproject/project.xml (-1 / +1 lines)
210	<compile-dependency/>	210	<compile-dependency/>
211	<run-dependency>	211	<run-dependency>
212	<release-version>1</release-version>	212	<release-version>1</release-version>
213	<specification-version>1.30</specification-version>	213	<specification-version>1.31</specification-version>
214	</run-dependency>	214	</run-dependency>
215	</dependency>	215	</dependency>
216	<dependency>	216	<dependency>




import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.classpath.GlobalPathRegistry;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectInformation;
import org.netbeans.api.project.ProjectManager;

import org.netbeans.spi.project.support.ant.PropertyEvaluator;
import org.netbeans.spi.project.support.ant.PropertyUtils;
import org.netbeans.spi.project.support.ant.ReferenceHelper;
import org.netbeans.spi.project.support.ant.SourcesHelper;
import org.netbeans.spi.project.ui.PrivilegedTemplates;
import org.netbeans.spi.project.ui.ProjectOpenedHook;
import org.netbeans.spi.project.ui.RecommendedTemplates;

    
    private Lookup createLookup(AuxiliaryConfiguration aux, ClassPathProviderImpl cpProvider) {
        SubprojectProvider spp = refHelper.createSubprojectProvider();
        
        // XXX unnecessarily creates a SourcesHelper, which is then GC's
        // as it is not hold. This is probably unneeded now that issue 63359 was fixed.
        final SourcesHelper sourcesHelper = new SourcesHelper(helper, evaluator());
        String configFilesLabel = NbBundle.getMessage(EarProject.class, "LBL_Node_ConfigBase"); //NOI18N
        
        sourcesHelper.addPrincipalSourceRoot("${"+EarProjectProperties.META_INF+"}", configFilesLabel, /*XXX*/null, null); // NOI18N
        ProjectManager.mutex().postWriteRequest(new Runnable() {
            public void run() {
                sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
            }
        });
        Lookup base = Lookups.fixed(new Object[] {
            new Info(),
            aux,

            LookupMergerSupport.createClassPathProviderMerger(cpProvider),
            new ProjectXmlSavedHookImpl(),
            UILookupMergerSupport.createProjectOpenHookMerger(new ProjectOpenedHookImpl()),
            new EarSources(this, helper, evaluator()),
            new RecommendedTemplatesImpl(),
            helper.createSharabilityQuery(evaluator(),
                    new String[] {"${"+EarProjectProperties.SOURCE_ROOT+"}"}, // NOI18N




import org.netbeans.api.project.SourceGroup;
import org.netbeans.api.project.ProjectManager;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.spi.project.support.ant.SourcesHelper;
import org.netbeans.spi.project.support.ant.AntProjectHelper;
import org.netbeans.spi.project.support.ant.PropertyEvaluator;


class EarSources implements Sources, PropertyChangeListener, ChangeListener  {

    private final Project project;
    private final AntProjectHelper helper;
    private final PropertyEvaluator evaluator;
    private Sources delegate;
    private final ChangeSupport changeSupport = new ChangeSupport(this);
    private SourcesHelper sourcesHelper;
    private boolean externalRootsRegistered;

    EarSources(Project project, AntProjectHelper helper, PropertyEvaluator evaluator) {
        this.project = project;
        this.helper = helper;
        this.evaluator = evaluator;
        initSources(); // have to register external build roots eagerly

    }

    private Sources initSources() {
        sourcesHelper = new SourcesHelper(project, helper, evaluator);
        String configFilesLabel = org.openide.util.NbBundle.getMessage(EarSources.class, "LBL_Node_ConfigBase"); //NOI18N
        sourcesHelper.addPrincipalSourceRoot("${"+EarProjectProperties.META_INF+"}", configFilesLabel, /*XXX*/null, null);
        // XXX add build dir too?
        sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
        ProjectManager.mutex().postWriteRequest(new Runnable() {
            public void run() {
                if (!externalRootsRegistered) {
                    sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
                    externalRootsRegistered = true;
                }
            }
        });
        return sourcesHelper.createSources();
    }


Lines 280-286 Link Here

(-)a/j2ee.ejbjarproject/nbproject/project.xml (-1 / +1 lines)
280	<compile-dependency/>	280	<compile-dependency/>
281	<run-dependency>	281	<run-dependency>
282	<release-version>1</release-version>	282	<release-version>1</release-version>
283	<specification-version>1.30</specification-version>	283	<specification-version>1.31</specification-version>
284	</run-dependency>	284	</run-dependency>
285	</dependency>	285	</dependency>
286	<dependency>	286	<dependency>




import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.SwingUtilities;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.classpath.GlobalPathRegistry;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectManager;
import org.netbeans.api.project.ant.AntArtifact;

import org.netbeans.spi.project.ui.RecommendedTemplates;
import org.netbeans.spi.project.support.ant.ReferenceHelper;
import org.netbeans.spi.project.support.ant.PropertyEvaluator;
import org.netbeans.spi.project.support.ant.SourcesHelper;
import org.netbeans.spi.project.ui.ProjectOpenedHook;
import org.openide.filesystems.FileChangeListener;
import org.openide.filesystems.FileObject;

    
    private Lookup createLookup(AuxiliaryConfiguration aux, ClassPathProviderImpl cpProvider) {
        SubprojectProvider spp = refHelper.createSubprojectProvider();

        final SourcesHelper sourcesHelper = new SourcesHelper(helper, evaluator());
        String ejbModuleLabel = org.openide.util.NbBundle.getMessage(EjbJarLogicalViewProvider.class, "LBL_Node_EJBModule"); //NOI18N
        String configFilesLabel = org.openide.util.NbBundle.getMessage(EjbJarLogicalViewProvider.class, "LBL_Node_DocBase"); //NOI18N
        
        sourcesHelper.addPrincipalSourceRoot("${"+EjbJarProjectProperties.SOURCE_ROOT+"}", ejbModuleLabel, /*XXX*/null, null);
        sourcesHelper.addPrincipalSourceRoot("${"+EjbJarProjectProperties.META_INF+"}", configFilesLabel, /*XXX*/null, null);
        
        ProjectManager.mutex().postWriteRequest(new Runnable() {
            public void run() {
                sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
            }
        });
        FileEncodingQueryImplementation encodingQuery = QuerySupport.createFileEncodingQuery(evaluator(), EjbJarProjectProperties.SOURCE_ENCODING);
        Lookup base = Lookups.fixed(new Object[] {
                EjbJarProject.this, // never cast an externally obtained Project to EjbJarProject - use lookup instead

                UILookupMergerSupport.createProjectOpenHookMerger(new ProjectOpenedHookImpl()),
                QuerySupport.createUnitTestForSourceQuery(getSourceRoots(), getTestSourceRoots()),
                QuerySupport.createSourceLevelQuery(evaluator()),
                new EjbJarSources(this, helper, evaluator(), getSourceRoots(), getTestSourceRoots()),
                QuerySupport.createSharabilityQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots(),
                        EjbJarProjectProperties.META_INF),
                QuerySupport.createFileBuiltQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()),




import org.netbeans.api.project.ProjectManager;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.project.Project;
import org.netbeans.modules.java.api.common.SourceRoots;
import org.netbeans.modules.java.api.common.project.ProjectProperties;
import org.netbeans.spi.project.support.ant.SourcesHelper;

    private static final String BUILD_DIR_PROP = "${" + EjbJarProjectProperties.BUILD_DIR + "}";    //NOI18N
    private static final String DIST_DIR_PROP = "${" + EjbJarProjectProperties.DIST_DIR + "}";    //NOI18N

    private final Project project;
    private final AntProjectHelper helper;
    private final PropertyEvaluator evaluator;
    private final SourceRoots sourceRoots;
    private final SourceRoots testRoots;
    private Sources delegate;
    /**
     * Flag to forbid multiple invocation of {@link SourcesHelper#registerExternalRoots} 
     **/
    private boolean externalRootsRegistered;    
    private final ChangeSupport changeSupport = new ChangeSupport(this);
    private SourcesHelper sourcesHelper;

    EjbJarSources(Project project, AntProjectHelper helper, PropertyEvaluator evaluator,
                SourceRoots sourceRoots, SourceRoots testRoots) {
        this.project = project;
        this.helper = helper;
        this.evaluator = evaluator;
        this.sourceRoots = sourceRoots;

    }

    private Sources initSources() {
        sourcesHelper = new SourcesHelper(project, helper, evaluator);
        register(sourceRoots);
        register(testRoots);
        

        sourcesHelper.addNonSourceRoot(BUILD_DIR_PROP);
        sourcesHelper.addNonSourceRoot(DIST_DIR_PROP);
        
        sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
        ProjectManager.mutex().postWriteRequest(new Runnable() {
            public void run() {
                if (!externalRootsRegistered) {
                    sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
                    externalRootsRegistered = true;
                }
            }
        });
        return sourcesHelper.createSources();
    }


Lines 180-186 Link Here

(-)a/java.j2seproject/nbproject/project.xml (-1 / +1 lines)
180	<compile-dependency/>	180	<compile-dependency/>
181	<run-dependency>	181	<run-dependency>
182	<release-version>1</release-version>	182	<release-version>1</release-version>
183	<specification-version>1.28</specification-version>	183	<specification-version>1.31</specification-version>
184	</run-dependency>	184	</run-dependency>
185	</dependency>	185	</dependency>
186	<dependency>	186	<dependency>




    private final PropertyEvaluator eval;
    private final ReferenceHelper refHelper;
    private final GeneratedFilesHelper genFilesHelper;
    private Lookup lookup;
    private final UpdateHelper updateHelper;
    private MainClassUpdater mainClassUpdater;
    private SourceRoots sourceRoots;

            UILookupMergerSupport.createProjectOpenHookMerger(new ProjectOpenedHookImpl()),
            QuerySupport.createUnitTestForSourceQuery(getSourceRoots(), getTestSourceRoots()),
            QuerySupport.createSourceLevelQuery(evaluator()),
            new J2SESources(this, helper, evaluator(), getSourceRoots(), getTestSourceRoots()),
            QuerySupport.createSharabilityQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()),
            new CoSAwareFileBuiltQueryImpl(QuerySupport.createFileBuiltQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()), this),
            new RecommendedTemplatesImpl (this.updateHelper),

            LookupMergerSupport.createJFBLookupMerger(),
            QuerySupport.createBinaryForSourceQueryImplementation(this.sourceRoots, this.testRoots, this.helper, this.eval) //Does not use APH to get/put properties/cfgdata
        );
        lookup = base; // in case LookupProvider's call Project.getLookup
        return LookupProviderSupport.createCompositeLookup(base, "Projects/org-netbeans-modules-java-j2seproject/Lookup"); //NOI18N
    }
    




import org.netbeans.api.project.ProjectManager;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.project.Project;
import org.netbeans.modules.java.api.common.SourceRoots;
import org.netbeans.modules.java.api.common.project.ProjectProperties;
import org.netbeans.spi.project.support.GenericSources;

    private static final String BUILD_DIR_PROP = "${" + J2SEProjectProperties.BUILD_DIR + "}";    //NOI18N
    private static final String DIST_DIR_PROP = "${" + J2SEProjectProperties.DIST_DIR + "}";    //NOI18N

    private final Project project;
    private final AntProjectHelper helper;
    private final PropertyEvaluator evaluator;
    private final SourceRoots sourceRoots;
    private final SourceRoots testRoots;
    private SourcesHelper sourcesHelper;
    private Sources delegate;
    /**
     * Flag to forbid multiple invocation of {@link SourcesHelper#registerExternalRoots} 
     **/
    private boolean externalRootsRegistered;    
    private final ChangeSupport changeSupport = new ChangeSupport(this);

    J2SESources(Project project, AntProjectHelper helper, PropertyEvaluator evaluator,
                SourceRoots sourceRoots, SourceRoots testRoots) {
        this.project = project;
        this.helper = helper;
        this.evaluator = evaluator;
        this.sourceRoots = sourceRoots;

    }
    
    private Sources initSources() {
        this.sourcesHelper = new SourcesHelper(project, helper, evaluator);   //Safe to pass APH        
        register(sourceRoots);
        register(testRoots);
        this.sourcesHelper.addNonSourceRoot(BUILD_DIR_PROP);
        this.sourcesHelper.addNonSourceRoot(DIST_DIR_PROP);
        sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT, false);
        ProjectManager.mutex().postWriteRequest(new Runnable() {
            public void run() {                
                if (!externalRootsRegistered) {
                    sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT, false);
                    externalRootsRegistered = true;
                }
            }
        });
        return this.sourcesHelper.createSources();
    }





    <!-- ACTUAL CHANGES BEGIN HERE: -->

    <changes>

        <change id="SourcesHelper-Project-constructor">
            <api name="general"/>
            <summary>Added <code>SourcesHelper</code> constructor accepting <code>Project</code></summary>
            <version major="1" minor="31"/>
            <date day="27" month="3" year="2009"/>
            <author login="tzezula"/>
            <compatibility addition="yes" deprecation="yes"/>
            <description>
                <p>
                    The new constructor enables simplified control flow.
                </p>
            </description>
            <class package="org.netbeans.spi.project.support.ant" name="SourcesHelper"/>
            <issue number="146852"/>
        </change>
        
        <change id="antbasedprojectregistration">
            <api name="general"/>

Lines 1-6 Link Here

(-)a/project.ant/manifest.mf (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	OpenIDE-Module: org.netbeans.modules.project.ant/1	2	OpenIDE-Module: org.netbeans.modules.project.ant/1
3	OpenIDE-Module-Specification-Version: 1.30	3	OpenIDE-Module-Specification-Version: 1.31
4	OpenIDE-Module-Layer: org/netbeans/modules/project/ant/resources/mf-layer.xml	4	OpenIDE-Module-Layer: org/netbeans/modules/project/ant/resources/mf-layer.xml
5	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/project/ant/Bundle.properties	5	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/project/ant/Bundle.properties
6	OpenIDE-Module-Install: org/netbeans/modules/project/ant/AntProjectModule.class	6	OpenIDE-Module-Install: org/netbeans/modules/project/ant/AntProjectModule.class




import org.openide.filesystems.FileStateInvalidException;
import org.openide.filesystems.FileUtil;
import org.openide.util.ChangeSupport;
import org.openide.util.Parameters;
import org.openide.util.WeakListeners;

// XXX should perhaps be legal to call add* methods at any time (should update things)

            if (val == null) {
                return null;
            }
            return aph.resolveFile(val);
        }
        public Collection<FileObject> getIncludeRoots(boolean minimalSubfolders) {
            File loc = getActualLocation();

        }
    }
    
    private final AntProjectHelper aph;
    private final Project project;
    private final PropertyEvaluator evaluator;
    private final List<SourceRoot> principalSourceRoots = new ArrayList<SourceRoot>();
    private final List<Root> nonSourceRoots = new ArrayList<Root>();

    /**
     * Create the helper object, initially configured to recognize only sources
     * contained inside the project directory.
     * @param aph an Ant project helper
     * @param evaluator a way to evaluate Ant properties used to define source locations
     * @deprecated Rather use {@link #SourcesHelper(Project, AntProjectHelper, PropertyEvaluator)}.
     */
    @Deprecated
    public SourcesHelper(AntProjectHelper aph, PropertyEvaluator evaluator) {
        this.project = null;
        this.aph = aph;
        this.evaluator = evaluator;
    }
    
    /**
     * Create the helper object, initially configured to recognize only sources
     * contained inside the project directory.
     * @param project the project object (need not yet be registered in {@link ProjectManager})
     * @param aph an Ant project helper
     * @param evaluator a way to evaluate Ant properties used to define source locations
     * @since org.netbeans.modules.project.ant/1 1.31
     */
    public SourcesHelper(Project project, AntProjectHelper aph, PropertyEvaluator evaluator) {
        Parameters.notNull("project", project);
        this.project = project;
        this.aph = aph;
        this.evaluator = evaluator;
    }
    

    }
    
    private Project getProject() {
        return project != null ? project : AntBasedProjectFactorySingleton.getProjectFor(aph);
    }
    
    /**

     * {@link FileOwnerQuery#EXTERNAL_ALGORITHM_TRANSIENT}.
     * </p>
     * <p>
     * If you used the old constructor form
     * {@link #SourcesHelper(AntProjectHelper, PropertyEvaluator)}
     * then you may <em>not</em> call this method inside the project's constructor, as
     * it requires the actual project to exist and be registered in {@link ProjectManager};
     * in this case you could still use {@link org.openide.util.Mutex#postWriteRequest} to run it
     * later, if you were creating the helper in your constructor, since the project construction
     * normally occurs in read access.
     * Better to use {@link #SourcesHelper(Project, AntProjectHelper, PropertyEvaluator)}.
     * </p>
     * @param algorithm an external root registration algorithm as per
     *                  {@link FileOwnerQuery#markExternalOwner}

        allRoots.addAll(nonSourceRoots);
        allRoots.addAll(ownedFiles);
        Project p = getProject();
        FileObject pdir = aph.getProjectDirectory();
        // First time: register roots and add to lastRegisteredRoots.
        // Subsequent times: add to newRootsToRegister and maybe add them later.
        if (lastRegisteredRoots == null) {




    private Project project2;
    private SourcesHelper sh2;
    
    protected @Override void setUp() throws Exception {
        super.setUp();
        MockLookup.setInstances(AntBasedTestUtil.testAntBasedProjectType());
        scratch = TestUtil.makeScratchDir(this);

        p.setProperty("ext.file", "../../external/extFile");
        h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);
        ProjectManager.getDefault().saveProject(project);
        sh = new SourcesHelper(project, h, h.getStandardPropertyEvaluator());
        sh.addPrincipalSourceRoot("${src1.dir}", "Sources #1", null, null); // inside proj dir
        sh.addPrincipalSourceRoot("${src2.dir}", "Sources #2", null, null); // outside (rel path)
        sh.addPrincipalSourceRoot("${src2a.dir}", "Sources #2a", null, null); // redundant

        h2 = ProjectGenerator.createProject(proj2dir, "test");
        project2 = ProjectManager.getDefault().findProject(proj2dir);
        assertNotNull("have a project2", project2);
        sh2 = new SourcesHelper(project2, h2, h2.getStandardPropertyEvaluator());
        sh2.addPrincipalSourceRoot("src1", "Sources #1", null, null);
        sh2.addPrincipalSourceRoot("src2", "Sources #2", null, null);
        sh2.addNonSourceRoot("build");

        // <editor-fold desc="other setup #2">
        h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);
        ProjectManager.getDefault().saveProject(project);
        sh = new SourcesHelper(project, h, h.getStandardPropertyEvaluator());
        sh.addPrincipalSourceRoot("${src1.dir}", "${src1.includes}", "${src1.excludes}", "Sources #1", null, null);
        sh.addPrincipalSourceRoot("${src2.dir}", "${src2.includes}", "${src2.excludes}", "Sources #2", null, null);
        sh.addPrincipalSourceRoot("${src3.dir}", "${src3.includes}", null, "Sources #3", null, null);

        h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);
        ProjectManager.getDefault().saveProject(project);
        //minimalSubfolders = true
        sh = new SourcesHelper(project, h, h.getStandardPropertyEvaluator());
        sh.addPrincipalSourceRoot("${src1.dir}", "${src1.includes}", "${src1.excludes}", "Sources #1", null, null);
        sh.addTypedSourceRoot("${src1.dir}", "${src1.includes}", "${src1.excludes}", "java", "Packages #1", null, null);
        sh.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT, true);

        assertEquals("Packages #1", g1.getDisplayName());
        assertNull(FileOwnerQuery.getOwner(src1dir));
        //minimalSubfolders = false
        sh = new SourcesHelper(project, h, h.getStandardPropertyEvaluator());
        sh.addPrincipalSourceRoot("${src1.dir}", "${src1.includes}", "${src1.excludes}", "Sources #1", null, null);
        sh.addTypedSourceRoot("${src1.dir}", "${src1.includes}", "${src1.excludes}", "java", "Packages #1", null, null);
        sh.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT, false);

Lines 95-100 Link Here

(-)a/projectapi/src/org/netbeans/modules/projectapi/AuxiliaryConfigBasedPreferencesProvider.java (+1 lines)
95	}	95	}
96		96
97	AuxiliaryConfiguration ac = ProjectUtils.getAuxiliaryConfiguration(p);	97	AuxiliaryConfiguration ac = ProjectUtils.getAuxiliaryConfiguration(p);
		98	assert p.getLookup() != null : p;
98	AuxiliaryProperties ap = p.getLookup().lookup(AuxiliaryProperties.class);	99	AuxiliaryProperties ap = p.getLookup().lookup(AuxiliaryProperties.class);
99		100
100	target.put(p, new WeakReference<AuxiliaryConfigBasedPreferencesProvider>(prov = new AuxiliaryConfigBasedPreferencesProvider(p, ac, ap, shared)));	101	target.put(p, new WeakReference<AuxiliaryConfigBasedPreferencesProvider>(prov = new AuxiliaryConfigBasedPreferencesProvider(p, ac, ap, shared)));




package org.netbeans.modules.projectimport.eclipse.core;

import java.util.concurrent.ExecutionException;
import java.util.logging.Logger;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ui.OpenProjects;
import org.netbeans.spi.project.ui.ProjectOpenedHook;
import org.openide.util.Exceptions;
import org.openide.util.RequestProcessor;

/**
 *
 */
public class ProjectOpenHookImpl extends ProjectOpenedHook{

    private static final RequestProcessor PROJ_OPEN_HOOK_RESYNCHRONIZER = new RequestProcessor("Eclipse.Resynchronizer"); // NOI18N
    private static RequestProcessor.Task currentTask;
    
    public ProjectOpenHookImpl() {}
    private Project project;
    
    private static final Logger LOG =
            Logger.getLogger(ProjectOpenHookImpl.class.getName());
    
    public ProjectOpenHookImpl(Project project, UpgradableProject upgradable) {
        this.upgradable = upgradable;
        this.project = project;
    }
    
    @Override
    protected synchronized void projectOpened() {




package org.netbeans.modules.projectimport.eclipse.core.spi;

import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectUtils;
import org.netbeans.modules.projectimport.eclipse.core.ProjectOpenHookImpl;
import org.netbeans.modules.projectimport.eclipse.core.UpgradableProject;
import org.netbeans.spi.project.LookupProvider;
import org.openide.util.Lookup;
import org.openide.util.lookup.Lookups;

// registered separately in j2se and web modules, otherwise could use @LookupProvider.Registration
final public class UpgradableProjectLookupProvider implements LookupProvider {

    public Lookup createAdditionalLookup(Lookup baseContext) {
        Project p = baseContext.lookup(Project.class);
        assert p != null;
        if (ProjectUtils.getPreferences(p, UpgradableProjectLookupProvider.class, true).
                get("project", null) == null) { // NOI18N
            // Shortcut, the normal case:
            return Lookup.EMPTY;
        } else {
            // Keep as separate method to try to delay class initialization:
            return upgradeLookup(p);
        }
    }

    private static Lookup upgradeLookup(Project p) {
        return Lookups.fixed(
            new UpgradableProject(p),
            new ProjectOpenHookImpl());
    }

}




import java.util.Collections;
import java.util.List;
import org.netbeans.api.java.platform.JavaPlatform;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectManager;
import org.netbeans.api.project.ProjectUtils;

                model.getEclipseTestSourceRootsAsFileArray(), null, null, null);
        J2SEProject p = (J2SEProject)ProjectManager.getDefault().findProject(helper.getProjectDirectory());
        List<String> importProblems = new ArrayList<String>();
        
        //
        // NB-Core-Build #1293: "No project found to correspond to .../spcp/eclipse/src" from ProjectClassPathModifier.findExtensible
        // 
        // Looks like J2SEProject registers its external source roots asynchronously and sometimes 
        // it is too late and above problem happens. Mark external source roots explicitly here:
        FileOwnerQuery.markExternalOwner(model.getEclipseSourceRootsAsFileArray()[0].toURI(), p, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
        
        ProjectFactorySupport.updateProjectClassPath(helper, p.getReferenceHelper(), model, importProblems);
        EditableProperties ep = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
        assertEquals(

                model.getEclipseTestSourceRootsAsFileArray(), null, null, null);
        J2SEProject p = (J2SEProject)ProjectManager.getDefault().findProject(helper.getProjectDirectory());
        List<String> importProblems = new ArrayList<String>();
        
        //
        // NB-Core-Build #1293: "No project found to correspond to .../spcp/eclipse/src" from ProjectClassPathModifier.findExtensible
        // 
        // Looks like J2SEProject registers its external source roots asynchronously and sometimes 
        // it is too late and above problem happens. Mark external source roots explicitly here:
        FileOwnerQuery.markExternalOwner(model.getEclipseSourceRootsAsFileArray()[0].toURI(), p, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
        
        ProjectFactorySupport.updateProjectClassPath(helper, p.getReferenceHelper(), model, importProblems);
        EditableProperties ep = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
        assertEquals(

                model.getEclipseTestSourceRootsAsFileArray(), null, null, null);
        J2SEProject p = (J2SEProject)ProjectManager.getDefault().findProject(helper.getProjectDirectory());
        List<String> importProblems = new ArrayList<String>();
        
        //
        // NB-Core-Build #1293: "No project found to correspond to .../spcp/eclipse/src" from ProjectClassPathModifier.findExtensible
        // 
        // Looks like J2SEProject registers its external source roots asynchronously and sometimes 
        // it is too late and above problem happens. Mark external source roots explicitly here:
        FileOwnerQuery.markExternalOwner(model.getEclipseSourceRootsAsFileArray()[0].toURI(), p, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
        
        ProjectFactorySupport.updateProjectClassPath(helper, p.getReferenceHelper(), model, importProblems);
        EditableProperties ep = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
        // required project "JavaLibrary1" is not available and therefore should not be

                mdl_d.getEclipseTestSourceRootsAsFileArray(), null, null, null);
        List<String> problems = new ArrayList<String>();
        J2SEProject j2seprj_d = (J2SEProject) ProjectManager.getDefault().findProject(aph_d.getProjectDirectory());
        
        //
        // NB-Core-Build #1293: "No project found to correspond to .../spcp/eclipse/src" from ProjectClassPathModifier.findExtensible
        // 
        // Looks like J2SEProject registers its external source roots asynchronously and sometimes 
        // it is too late and above problem happens. Mark external source roots explicitly here:
        FileOwnerQuery.markExternalOwner(mdl_d.getEclipseSourceRootsAsFileArray()[0].toURI(), j2seprj_d, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
        
        ProjectFactorySupport.updateProjectClassPath(aph_d, j2seprj_d.getReferenceHelper(), mdl_d, problems);
        assertEquals(Collections.emptyList(), problems);
        assertEquals("${reference.c.jar}:${reference.b.jar}", aph_d.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH).get("javac.classpath"));

Lines 185-191 Link Here

(-)a/web.project/src/org/netbeans/modules/web/project/WebProject.java (-1 / +2 lines)
185	private final PropertyEvaluator eval;	185	private final PropertyEvaluator eval;
186	private final ReferenceHelper refHelper;	186	private final ReferenceHelper refHelper;
187	private final GeneratedFilesHelper genFilesHelper;	187	private final GeneratedFilesHelper genFilesHelper;
188	private final Lookup lookup;	188	private Lookup lookup;
189	private final ProjectWebModule webModule;	189	private final ProjectWebModule webModule;
190	private final CopyOnSaveSupport css;	190	private final CopyOnSaveSupport css;
191	private final ArtifactCopyOnSaveSupport artifactSupport;	191	private final ArtifactCopyOnSaveSupport artifactSupport;
Lines 528-533 Link Here
528	LookupMergerSupport.createJFBLookupMerger(),	528	LookupMergerSupport.createJFBLookupMerger(),
529	QuerySupport.createBinaryForSourceQueryImplementation(sourceRoots, testRoots, helper, eval),	529	QuerySupport.createBinaryForSourceQueryImplementation(sourceRoots, testRoots, helper, eval),
530	});	530	});
		531	lookup = base;
531	return LookupProviderSupport.createCompositeLookup(base, "Projects/org-netbeans-modules-web-project/Lookup"); //NOI18N	532	return LookupProviderSupport.createCompositeLookup(base, "Projects/org-netbeans-modules-web-project/Lookup"); //NOI18N
532	}	533	}
533		534

Return to bug 146852

Lines 84-90 Link Here

(-)a/ant.freeform/src/org/netbeans/modules/ant/freeform/FreeformSources.java (-6 / +2 lines)
84	}	84	}
85		85
86	private Sources initSources() {	86	private Sources initSources() {
87	final SourcesHelper h = new SourcesHelper(project.helper(), project.evaluator());	87	SourcesHelper h = new SourcesHelper(project, project.helper(), project.evaluator());
88	Element genldata = project.getPrimaryConfigurationData();	88	Element genldata = project.getPrimaryConfigurationData();
89	Element foldersE = Util.findElement(genldata, "folders", FreeformProjectType.NS_GENERAL); // NOI18N	89	Element foldersE = Util.findElement(genldata, "folders", FreeformProjectType.NS_GENERAL); // NOI18N
90	if (foldersE != null) {	90	if (foldersE != null) {
Lines 119-129 Link Here
119	}	119	}
120	}	120	}
121	}	121	}
122	ProjectManager.mutex().postWriteRequest(new Runnable() {	122	h.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
123	public void run() {
124	h.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
125	}
126	});
127	return h.createSources();	123	return h.createSources();
128	}	124	}
129		125

Lines 58-64 Link Here

(-)a/apisupport.project/src/org/netbeans/modules/apisupport/project/NbModuleProject.java (-7 / +2 lines)
58	import java.util.logging.Level;	58	import java.util.logging.Level;
59	import java.util.logging.Logger;	59	import java.util.logging.Logger;
60	import javax.swing.Icon;	60	import javax.swing.Icon;
61	import javax.swing.ImageIcon;
62	import org.netbeans.api.java.classpath.ClassPath;	61	import org.netbeans.api.java.classpath.ClassPath;
63	import org.netbeans.api.java.classpath.GlobalPathRegistry;	62	import org.netbeans.api.java.classpath.GlobalPathRegistry;
64	import org.netbeans.api.java.project.JavaProjectConstants;	63	import org.netbeans.api.java.project.JavaProjectConstants;
Lines 179-185 Link Here
179	}	178	}
180	FileBuiltQueryImplementation fileBuilt = helper.createGlobFileBuiltQuery(	179	FileBuiltQueryImplementation fileBuilt = helper.createGlobFileBuiltQuery(
181	eval,from.toArray(new String[0]), to.toArray(new String[0]));	180	eval,from.toArray(new String[0]), to.toArray(new String[0]));
182	final SourcesHelper sourcesHelper = new SourcesHelper(helper, eval);	181	SourcesHelper sourcesHelper = new SourcesHelper(this, helper, eval);
183	// Temp build dir is always internal; NBM build products go elsewhere, but	182	// Temp build dir is always internal; NBM build products go elsewhere, but
184	// difficult to predict statically exactly what they are!	183	// difficult to predict statically exactly what they are!
185	// XXX would be good to mark at least the module JAR as owned by this project	184	// XXX would be good to mark at least the module JAR as owned by this project
Lines 204-214 Link Here
204	/* XXX should schema incl. display name? */entry.getKey().getNameExt(), null, null);	203	/* XXX should schema incl. display name? */entry.getKey().getNameExt(), null, null);
205	}	204	}
206	// #56457: support external source roots too.	205	// #56457: support external source roots too.
207	ProjectManager.mutex().postWriteRequest(new Runnable() {	206	sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
208	public void run() {
209	sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
210	}
211	});
212	lookup = createLookup(new Info(), aux, helper, fileBuilt, sourcesHelper);	207	lookup = createLookup(new Info(), aux, helper, fileBuilt, sourcesHelper);
213	}	208	}
214		209

Lines 34-48 Link Here

(-)a/bpel.project/src/org/netbeans/modules/bpel/project/BpelproProject.java (-12 / +2 lines)
34	import java.util.Set;	34	import java.util.Set;
35	import java.util.logging.Logger;	35	import java.util.logging.Logger;
36	import javax.swing.Icon;	36	import javax.swing.Icon;
37	import javax.swing.ImageIcon;
38	import org.netbeans.api.java.project.JavaProjectConstants;	37	import org.netbeans.api.java.project.JavaProjectConstants;
39	import org.netbeans.api.project.FileOwnerQuery;	38	import org.netbeans.api.project.FileOwnerQuery;
40	import org.netbeans.api.project.Project;	39	import org.netbeans.api.project.Project;
41	import org.netbeans.api.project.ProjectManager;	40	import org.netbeans.api.project.ProjectManager;
42	import org.netbeans.api.project.ant.AntArtifact;	41	import org.netbeans.api.project.ant.AntArtifact;
43	import org.openide.cookies.SaveCookie;
44	import org.openide.loaders.DataObject;
45	import org.openide.loaders.DataObjectNotFoundException;
46	import org.openide.filesystems.FileUtil;	42	import org.openide.filesystems.FileUtil;
47	import org.openide.filesystems.FileChangeListener;	43	import org.openide.filesystems.FileChangeListener;
48	import org.openide.filesystems.FileEvent;	44	import org.openide.filesystems.FileEvent;
Lines 50-56 Link Here
50	import org.openide.filesystems.FileAttributeEvent;	46	import org.openide.filesystems.FileAttributeEvent;
51	import org.openide.filesystems.FileLock;	47	import org.openide.filesystems.FileLock;
52	import org.netbeans.modules.compapp.projects.base.spi.JbiArtifactProvider;	48	import org.netbeans.modules.compapp.projects.base.spi.JbiArtifactProvider;
53	import org.netbeans.modules.compapp.projects.base.ui.IcanproCustomizerProvider;
54	import org.netbeans.modules.compapp.projects.base.ui.customizer.IcanproProjectProperties;	49	import org.netbeans.modules.compapp.projects.base.ui.customizer.IcanproProjectProperties;
55	import org.netbeans.modules.bpel.model.api.support.Utils;	50	import org.netbeans.modules.bpel.model.api.support.Utils;
56	import org.netbeans.api.project.ProjectInformation;	51	import org.netbeans.api.project.ProjectInformation;
Lines 77-83 Link Here
77	import org.openide.util.ImageUtilities;	72	import org.openide.util.ImageUtilities;
78	import org.openide.util.Lookup;	73	import org.openide.util.Lookup;
79	import org.openide.util.Mutex;	74	import org.openide.util.Mutex;
80	import org.openide.util.Utilities;
81	import org.openide.util.lookup.Lookups;	75	import org.openide.util.lookup.Lookups;
82	import org.netbeans.spi.java.project.support.ui.BrokenReferencesSupport;	76	import org.netbeans.spi.java.project.support.ui.BrokenReferencesSupport;
83	import org.netbeans.spi.project.AuxiliaryConfiguration;	77	import org.netbeans.spi.project.AuxiliaryConfiguration;
Lines 170-176 Link Here
170	new String[] {"${src.dir}/*.java"}, // NOI18N	164	new String[] {"${src.dir}/*.java"}, // NOI18N
171	new String[] {"${build.classes.dir}/*.class"} // NOI18N	165	new String[] {"${build.classes.dir}/*.class"} // NOI18N
172	);	166	);
173	final SourcesHelper sourcesHelper = new SourcesHelper(helper, evaluator());	167	SourcesHelper sourcesHelper = new SourcesHelper(this, helper, evaluator());
174	String webModuleLabel = org.openide.util.NbBundle.getMessage(ProjectLogicalViewProvider.class, "LBL_Node_EJBModule"); //NOI18N	168	String webModuleLabel = org.openide.util.NbBundle.getMessage(ProjectLogicalViewProvider.class, "LBL_Node_EJBModule"); //NOI18N
175	String srcJavaLabel = org.openide.util.NbBundle.getMessage(ProjectLogicalViewProvider.class, "LBL_Node_Sources"); //NOI18N	169	String srcJavaLabel = org.openide.util.NbBundle.getMessage(ProjectLogicalViewProvider.class, "LBL_Node_Sources"); //NOI18N
176		170
Lines 182-192 Link Here
182	org.netbeans.modules.xml.catalogsupport.ProjectConstants.SOURCES_TYPE_XML,	176	org.netbeans.modules.xml.catalogsupport.ProjectConstants.SOURCES_TYPE_XML,
183	srcJavaLabel, null, null);	177	srcJavaLabel, null, null);
184		178
185	ProjectManager.mutex().postWriteRequest(new Runnable() {	179	sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
186	public void run() {
187	sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
188	}
189	});
190	return Lookups.fixed(new Object[] {	180	return Lookups.fixed(new Object[] {
191	new Info(),	181	new Info(),
192	aux,	182	aux,

Lines 47-53 Link Here

(-)a/cnd.makeproject/src/org/netbeans/modules/cnd/makeproject/MakeSources.java (-8 / +2 lines)
47	import java.util.Set;	47	import java.util.Set;
48	import javax.swing.event.ChangeListener;	48	import javax.swing.event.ChangeListener;
49	import org.netbeans.api.project.FileOwnerQuery;	49	import org.netbeans.api.project.FileOwnerQuery;
50	import org.netbeans.api.project.ProjectManager;
51	import org.netbeans.api.project.SourceGroup;	50	import org.netbeans.api.project.SourceGroup;
52	import org.netbeans.api.project.Sources;	51	import org.netbeans.api.project.Sources;
53	import org.netbeans.modules.cnd.api.utils.IpeUtils;	52	import org.netbeans.modules.cnd.api.utils.IpeUtils;
Lines 95-101 Link Here
95	}	94	}
96		95
97	private Sources initSources() {	96	private Sources initSources() {
98	final SourcesHelper h = new SourcesHelper(helper, project.evaluator());	97	SourcesHelper h = new SourcesHelper(project, helper, project.evaluator());
99	ConfigurationDescriptorProvider pdp = project.getLookup().lookup(ConfigurationDescriptorProvider.class);	98	ConfigurationDescriptorProvider pdp = project.getLookup().lookup(ConfigurationDescriptorProvider.class);
100	ConfigurationDescriptor pd = pdp.getConfigurationDescriptor(!MakeProjectConfigurationProvider.ASYNC_LOAD);	99	ConfigurationDescriptor pd = pdp.getConfigurationDescriptor(!MakeProjectConfigurationProvider.ASYNC_LOAD);
101	if (pd != null) {	100	if (pd != null) {
Lines 159-170 Link Here
159	h.addTypedSourceRoot(name, "generic", displayName, null, null); // NOI18N	158	h.addTypedSourceRoot(name, "generic", displayName, null, null); // NOI18N
160	}	159	}
161	}	160	}
162	ProjectManager.mutex().postWriteRequest(new Runnable() {	161	h.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
163
164	public void run() {
165	h.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
166	}
167	});
168	return h.createSources();	162	return h.createSources();
169	}	163	}
170		164

Lines 26-35 Link Here

(-)a/compapp.projects.base/src/org/netbeans/modules/compapp/projects/base/IcanproProject.java (-9 / +2 lines)
26	import java.nio.charset.Charset;	26	import java.nio.charset.Charset;
27	import java.nio.charset.IllegalCharsetNameException;	27	import java.nio.charset.IllegalCharsetNameException;
28	import java.nio.charset.UnsupportedCharsetException;	28	import java.nio.charset.UnsupportedCharsetException;
29	import java.util.*;
30	import java.util.logging.Logger;	29	import java.util.logging.Logger;
31	import javax.swing.Icon;	30	import javax.swing.Icon;
32	import javax.swing.ImageIcon;
33	import org.netbeans.api.project.FileOwnerQuery;	31	import org.netbeans.api.project.FileOwnerQuery;
34	import org.netbeans.api.project.Project;	32	import org.netbeans.api.project.Project;
35	import org.netbeans.api.project.ProjectManager;	33	import org.netbeans.api.project.ProjectManager;
Lines 59-65 Link Here
59	import org.openide.util.ImageUtilities;	57	import org.openide.util.ImageUtilities;
60	import org.openide.util.Lookup;	58	import org.openide.util.Lookup;
61	import org.openide.util.Mutex;	59	import org.openide.util.Mutex;
62	import org.openide.util.Utilities;
63	import org.openide.util.lookup.Lookups;	60	import org.openide.util.lookup.Lookups;
64	import org.netbeans.spi.project.AuxiliaryConfiguration;	61	import org.netbeans.spi.project.AuxiliaryConfiguration;
65	import org.netbeans.spi.project.support.ant.AntBasedProjectRegistration;	62	import org.netbeans.spi.project.support.ant.AntBasedProjectRegistration;
Lines 129-135 Link Here
129	new String[] {"${src.dir}/*.java"}, // NOI18N	126	new String[] {"${src.dir}/*.java"}, // NOI18N
130	new String[] {"${build.classes.dir}/*.class"} // NOI18N	127	new String[] {"${build.classes.dir}/*.class"} // NOI18N
131	);	128	);
132	final SourcesHelper sourcesHelper = new SourcesHelper(helper, evaluator());	129	SourcesHelper sourcesHelper = new SourcesHelper(this, helper, evaluator());
133	String webModuleLabel = org.openide.util.NbBundle.getMessage(IcanproCustomizerProvider.class, "LBL_Node_EJBModule"); //NOI18N	130	String webModuleLabel = org.openide.util.NbBundle.getMessage(IcanproCustomizerProvider.class, "LBL_Node_EJBModule"); //NOI18N
134	String srcJavaLabel = org.openide.util.NbBundle.getMessage(IcanproCustomizerProvider.class, "LBL_Node_Sources"); //NOI18N	131	String srcJavaLabel = org.openide.util.NbBundle.getMessage(IcanproCustomizerProvider.class, "LBL_Node_Sources"); //NOI18N
135		132
Lines 138-148 Link Here
138		135
139	sourcesHelper.addTypedSourceRoot("${"+IcanproProjectProperties.SRC_DIR+"}", SOURCES_TYPE_ICANPRO, srcJavaLabel, /XXX/null, null);	136	sourcesHelper.addTypedSourceRoot("${"+IcanproProjectProperties.SRC_DIR+"}", SOURCES_TYPE_ICANPRO, srcJavaLabel, /XXX/null, null);
140	// sourcesHelper.addTypedSourceRoot("${"+IcanproProjectProperties.SRC_DIR+"}", JavaProjectConstants.SOURCES_TYPE_JAVA, srcJavaLabel, /XXX/null, null);	137	// sourcesHelper.addTypedSourceRoot("${"+IcanproProjectProperties.SRC_DIR+"}", JavaProjectConstants.SOURCES_TYPE_JAVA, srcJavaLabel, /XXX/null, null);
141	ProjectManager.mutex().postWriteRequest(new Runnable() {	138	sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
142	public void run() {
143	sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
144	}
145	});
146	return Lookups.fixed(new Object[] {	139	return Lookups.fixed(new Object[] {
147	new Info(),	140	new Info(),
148	aux,	141	aux,

Lines 117-122 Link Here

(-)a/compapp.projects.jbi/nbproject/project.xml (-19 / +19 lines)
117	</run-dependency>	117	</run-dependency>
118	</dependency>	118	</dependency>
119	<dependency>	119	<dependency>
		120	<code-name-base>org.netbeans.libs.httpunit</code-name-base>
		121	<build-prerequisite/>
		122	<compile-dependency/>
		123	<run-dependency>
		124	<release-version>1</release-version>
		125	<specification-version>1.10</specification-version>
		126	</run-dependency>
		127	</dependency>
		128	<dependency>
		129	<code-name-base>org.netbeans.libs.jaxb</code-name-base>
		130	<build-prerequisite/>
		131	<compile-dependency/>
		132	<run-dependency>
		133	<release-version>1</release-version>
		134	<specification-version>1.3</specification-version>
		135	</run-dependency>
		136	</dependency>
		137	<dependency>
120	<code-name-base>org.netbeans.libs.xerces</code-name-base>	138	<code-name-base>org.netbeans.libs.xerces</code-name-base>
121	<build-prerequisite/>	139	<build-prerequisite/>
122	<compile-dependency/>	140	<compile-dependency/>
Lines 201-207 Link Here
201	<compile-dependency/>	219	<compile-dependency/>
202	<run-dependency>	220	<run-dependency>
203	<release-version>1</release-version>	221	<release-version>1</release-version>
204	<specification-version>1.30</specification-version>	222	<specification-version>1.31</specification-version>
205	</run-dependency>	223	</run-dependency>
206	</dependency>	224	</dependency>
207	<dependency>	225	<dependency>
Lines 241-255 Link Here
241	</run-dependency>	259	</run-dependency>
242	</dependency>	260	</dependency>
243	<dependency>	261	<dependency>
244	<code-name-base>org.netbeans.libs.jaxb</code-name-base>
245	<build-prerequisite/>
246	<compile-dependency/>
247	<run-dependency>
248	<release-version>1</release-version>
249	<specification-version>1.3</specification-version>
250	</run-dependency>
251	</dependency>
252	<dependency>
253	<code-name-base>org.netbeans.modules.websvc.jaxws21</code-name-base>	262	<code-name-base>org.netbeans.modules.websvc.jaxws21</code-name-base>
254	<build-prerequisite/>	263	<build-prerequisite/>
255	<compile-dependency/>	264	<compile-dependency/>
Lines 302-316 Link Here
302	</run-dependency>	311	</run-dependency>
303	</dependency>	312	</dependency>
304	<dependency>	313	<dependency>
305	<code-name-base>org.netbeans.libs.httpunit</code-name-base>
306	<build-prerequisite/>
307	<compile-dependency/>
308	<run-dependency>
309	<release-version>1</release-version>
310	<specification-version>1.10</specification-version>
311	</run-dependency>
312	</dependency>
313	<dependency>
314	<code-name-base>org.netbeans.soa.libs.jbiadmincommon</code-name-base>	314	<code-name-base>org.netbeans.soa.libs.jbiadmincommon</code-name-base>
315	<build-prerequisite/>	315	<build-prerequisite/>
316	<compile-dependency/>	316	<compile-dependency/>

Lines 69-75 Link Here

(-)a/compapp.projects.jbi/src/org/netbeans/modules/compapp/projects/jbi/JbiProject.java (-14 / +4 lines)
69	import org.openide.util.ImageUtilities;	69	import org.openide.util.ImageUtilities;
70	import org.openide.util.Lookup;	70	import org.openide.util.Lookup;
71	import org.openide.util.Mutex;	71	import org.openide.util.Mutex;
72	import org.openide.util.Utilities;
73	import org.openide.util.lookup.Lookups;	72	import org.openide.util.lookup.Lookups;
74	import org.openide.windows.TopComponent;	73	import org.openide.windows.TopComponent;
75	import org.w3c.dom.Element;	74	import org.w3c.dom.Element;
Lines 86-98 Link Here
86	import java.util.*;	85	import java.util.*;
87	import java.util.logging.Logger;	86	import java.util.logging.Logger;
88	import javax.swing.Icon;	87	import javax.swing.Icon;
89	import javax.swing.ImageIcon;
90	import javax.swing.SwingUtilities;	88	import javax.swing.SwingUtilities;
91	import org.netbeans.api.queries.FileEncodingQuery;	89	import org.netbeans.api.queries.FileEncodingQuery;
92	import org.netbeans.modules.compapp.projects.jbi.ComponentInfoGenerator;
93	import org.netbeans.modules.compapp.projects.jbi.queries.JbiProjectEncodingQueryImpl;	90	import org.netbeans.modules.compapp.projects.jbi.queries.JbiProjectEncodingQueryImpl;
94	import org.netbeans.modules.sun.manager.jbi.management.model.ComponentInformationParser;	91	import org.netbeans.modules.sun.manager.jbi.management.model.ComponentInformationParser;
95	import org.netbeans.modules.sun.manager.jbi.management.model.JBIComponentDocument;
96	import org.netbeans.modules.sun.manager.jbi.management.model.JBIComponentStatus;	92	import org.netbeans.modules.sun.manager.jbi.management.model.JBIComponentStatus;
97	import org.openide.filesystems.FileChangeAdapter;	93	import org.openide.filesystems.FileChangeAdapter;
98	import org.openide.filesystems.FileChangeListener;	94	import org.openide.filesystems.FileChangeListener;
Lines 253-259 Link Here
253	helper.getStandardPropertyEvaluator(), new String[] {"${src.dir}/*.java"}, // NOI18N	249	helper.getStandardPropertyEvaluator(), new String[] {"${src.dir}/*.java"}, // NOI18N
254	new String[] {"${build.classes.dir}/*.class"} // NOI18N	250	new String[] {"${build.classes.dir}/*.class"} // NOI18N
255	);	251	);
256	final SourcesHelper sourcesHelper = new SourcesHelper(helper, evaluator());	252	SourcesHelper sourcesHelper = new SourcesHelper(this, helper, evaluator());
257	String webModuleLabel = org.openide.util.NbBundle.getMessage(	253	String webModuleLabel = org.openide.util.NbBundle.getMessage(
258	JbiCustomizerProvider.class, "LBL_Node_EJBModule" // NOI18N	254	JbiCustomizerProvider.class, "LBL_Node_EJBModule" // NOI18N
259	);	255	);
Lines 279-293 Link Here
279	srcJavaLabel, /XXX/	275	srcJavaLabel, /XXX/
280	null, null	276	null, null
281	);	277	);
282	ProjectManager.mutex().postWriteRequest(	278	sourcesHelper.registerExternalRoots(
283	new Runnable() {	279	FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT
284	public void run() {	280	);
285	sourcesHelper.registerExternalRoots(
286	FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT
287	);
288	}
289	}
290	);
291		281
292	casaFileListener = new FileChangeAdapter() {	282	casaFileListener = new FileChangeAdapter() {
293	@Override	283	@Override

Lines 23-29 Link Here

(-)a/etl.project/src/org/netbeans/modules/etl/project/EtlproProject.java (-9 / +2 lines)
23	import java.io.IOException;	23	import java.io.IOException;
24	import java.io.File;	24	import java.io.File;
25	import javax.swing.Icon;	25	import javax.swing.Icon;
26	import javax.swing.ImageIcon;
27	import net.java.hulp.i18n.Logger;	26	import net.java.hulp.i18n.Logger;
28	import org.netbeans.api.java.project.JavaProjectConstants;	27	import org.netbeans.api.java.project.JavaProjectConstants;
29	import org.netbeans.api.project.FileOwnerQuery;	28	import org.netbeans.api.project.FileOwnerQuery;
Lines 53-59 Link Here
53	import org.openide.util.ImageUtilities;	52	import org.openide.util.ImageUtilities;
54	import org.openide.util.Lookup;	53	import org.openide.util.Lookup;
55	import org.openide.util.Mutex;	54	import org.openide.util.Mutex;
56	import org.openide.util.Utilities;
57	import org.openide.util.lookup.Lookups;	55	import org.openide.util.lookup.Lookups;
58	import org.netbeans.modules.compapp.projects.base.spi.JbiArtifactProvider;	56	import org.netbeans.modules.compapp.projects.base.spi.JbiArtifactProvider;
59	import org.netbeans.modules.etl.project.ui.EtlproLogicalViewProvider;	57	import org.netbeans.modules.etl.project.ui.EtlproLogicalViewProvider;
Lines 133-139 Link Here
133	new String[]{"${src.dir}/*.java"}, // NOI18N	131	new String[]{"${src.dir}/*.java"}, // NOI18N
134	new String[]{"${build.classes.dir}/*.class"} // NOI18N	132	new String[]{"${build.classes.dir}/*.class"} // NOI18N
135	);	133	);
136	final SourcesHelper sourcesHelper = new SourcesHelper(helper, evaluator());	134	SourcesHelper sourcesHelper = new SourcesHelper(this, helper, evaluator());
137	/*String nbBundle1 = mLoc.t("BUND711: EJB Module");	135	/*String nbBundle1 = mLoc.t("BUND711: EJB Module");
138	String nbBundle2 = mLoc.t("BUND712: Source Packages");	136	String nbBundle2 = mLoc.t("BUND712: Source Packages");
139	String webModuleLabel = nbBundle1.substring(15); //NOI18N	137	String webModuleLabel = nbBundle1.substring(15); //NOI18N
Lines 147-158 Link Here
147		145
148	sourcesHelper.addTypedSourceRoot("${" + IcanproProjectProperties.SRC_DIR + "}", SOURCES_TYPE_ICANPRO, srcJavaLabel, /XXX/ null, null);	146	sourcesHelper.addTypedSourceRoot("${" + IcanproProjectProperties.SRC_DIR + "}", SOURCES_TYPE_ICANPRO, srcJavaLabel, /XXX/ null, null);
149	sourcesHelper.addTypedSourceRoot("${" + IcanproProjectProperties.SRC_DIR + "}", JavaProjectConstants.SOURCES_TYPE_JAVA, srcJavaLabel, /XXX/ null, null);	147	sourcesHelper.addTypedSourceRoot("${" + IcanproProjectProperties.SRC_DIR + "}", JavaProjectConstants.SOURCES_TYPE_JAVA, srcJavaLabel, /XXX/ null, null);
150	ProjectManager.mutex().postWriteRequest(new Runnable() {	148	sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
151
152	public void run() {
153	sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
154	}
155	});
156	return Lookups.fixed(new Object[]{	149	return Lookups.fixed(new Object[]{
157	new Info(),	150	new Info(),
158	aux,	151	aux,

Lines 29-42 Link Here

(-)a/iep.project/src/org/netbeans/modules/iep/project/IepProject.java (-10 / +2 lines)
29	import java.io.File;	29	import java.io.File;
30	import java.io.IOException;	30	import java.io.IOException;
31	import javax.swing.Icon;	31	import javax.swing.Icon;
32	import javax.swing.ImageIcon;
33	import org.netbeans.modules.xml.catalogsupport.ProjectConstants;
34	import org.netbeans.api.project.FileOwnerQuery;	32	import org.netbeans.api.project.FileOwnerQuery;
35	import org.netbeans.api.project.Project;	33	import org.netbeans.api.project.Project;
36	import org.netbeans.api.project.ProjectInformation;	34	import org.netbeans.api.project.ProjectInformation;
37	import org.netbeans.api.project.ProjectManager;	35	import org.netbeans.api.project.ProjectManager;
38	import org.netbeans.api.project.ant.AntArtifact;	36	import org.netbeans.api.project.ant.AntArtifact;
39	import org.netbeans.modules.iep.project.ui.customizer.IepProjectCustomizerProvider;
40	import org.netbeans.spi.java.project.support.ui.BrokenReferencesSupport;	37	import org.netbeans.spi.java.project.support.ui.BrokenReferencesSupport;
41	import org.netbeans.spi.project.AuxiliaryConfiguration;	38	import org.netbeans.spi.project.AuxiliaryConfiguration;
42	import org.netbeans.spi.project.SubprojectProvider;	39	import org.netbeans.spi.project.SubprojectProvider;
Lines 59-65 Link Here
59	import org.openide.util.ImageUtilities;	56	import org.openide.util.ImageUtilities;
60	import org.openide.util.Lookup;	57	import org.openide.util.Lookup;
61	import org.openide.util.Mutex;	58	import org.openide.util.Mutex;
62	import org.openide.util.Utilities;
63	import org.openide.util.lookup.Lookups;	59	import org.openide.util.lookup.Lookups;
64	import org.w3c.dom.Element;	60	import org.w3c.dom.Element;
65	import org.w3c.dom.Node;	61	import org.w3c.dom.Node;
Lines 131-137 Link Here
131	new String[] {"${src.dir}/*.java"}, // NOI18N	127	new String[] {"${src.dir}/*.java"}, // NOI18N
132	new String[] {"${build.classes.dir}/*.class"} // NOI18N	128	new String[] {"${build.classes.dir}/*.class"} // NOI18N
133	);	129	);
134	final SourcesHelper sourcesHelper = new SourcesHelper(helper, evaluator());	130	SourcesHelper sourcesHelper = new SourcesHelper(this, helper, evaluator());
135	String webModuleLabel = org.openide.util.NbBundle.getMessage(IcanproCustomizerProvider.class, "LBL_Node_EJBModule"); //NOI18N	131	String webModuleLabel = org.openide.util.NbBundle.getMessage(IcanproCustomizerProvider.class, "LBL_Node_EJBModule"); //NOI18N
136	String srcJavaLabel = org.openide.util.NbBundle.getMessage(IepProjectLogicalViewProvider.class, "LBL_Node_Sources"); //NOI18N	132	String srcJavaLabel = org.openide.util.NbBundle.getMessage(IepProjectLogicalViewProvider.class, "LBL_Node_Sources"); //NOI18N
137		133
Lines 142-152 Link Here
142	sourcesHelper.addTypedSourceRoot("${"+IcanproProjectProperties.SRC_DIR+"}",	138	sourcesHelper.addTypedSourceRoot("${"+IcanproProjectProperties.SRC_DIR+"}",
143	org.netbeans.modules.xml.catalogsupport.ProjectConstants.SOURCES_TYPE_XML,	139	org.netbeans.modules.xml.catalogsupport.ProjectConstants.SOURCES_TYPE_XML,
144	srcJavaLabel, /XXX/null, null);	140	srcJavaLabel, /XXX/null, null);
145	ProjectManager.mutex().postWriteRequest(new Runnable() {	141	sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
146	public void run() {
147	sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
148	}
149	});
150	return Lookups.fixed(new Object[] {	142	return Lookups.fixed(new Object[] {
151	new Info(),	143	new Info(),
152	aux,	144	aux,

Lines 54-65 Link Here

(-)a/j2ee.clientproject/src/org/netbeans/modules/j2ee/clientproject/AppClientProject.java (-16 / +1 lines)
54	import java.util.logging.Level;	54	import java.util.logging.Level;
55	import java.util.logging.Logger;	55	import java.util.logging.Logger;
56	import javax.swing.Icon;	56	import javax.swing.Icon;
57	import javax.swing.ImageIcon;
58	import javax.swing.JButton;	57	import javax.swing.JButton;
59	import org.netbeans.api.java.classpath.ClassPath;	58	import org.netbeans.api.java.classpath.ClassPath;
60	import org.netbeans.api.java.classpath.GlobalPathRegistry;	59	import org.netbeans.api.java.classpath.GlobalPathRegistry;
61	import org.netbeans.api.java.project.JavaProjectConstants;	60	import org.netbeans.api.java.project.JavaProjectConstants;
62	import org.netbeans.api.project.FileOwnerQuery;
63	import org.netbeans.api.project.Project;	61	import org.netbeans.api.project.Project;
64	import org.netbeans.api.project.ProjectInformation;	62	import org.netbeans.api.project.ProjectInformation;
65	import org.netbeans.api.project.ProjectManager;	63	import org.netbeans.api.project.ProjectManager;
Lines 115-121 Link Here
115	import org.netbeans.spi.project.support.ant.PropertyEvaluator;	113	import org.netbeans.spi.project.support.ant.PropertyEvaluator;
116	import org.netbeans.spi.project.support.ant.PropertyUtils;	114	import org.netbeans.spi.project.support.ant.PropertyUtils;
117	import org.netbeans.spi.project.support.ant.ReferenceHelper;	115	import org.netbeans.spi.project.support.ant.ReferenceHelper;
118	import org.netbeans.spi.project.support.ant.SourcesHelper;
119	import org.netbeans.spi.project.ui.PrivilegedTemplates;	116	import org.netbeans.spi.project.ui.PrivilegedTemplates;
120	import org.netbeans.spi.project.ui.ProjectOpenedHook;	117	import org.netbeans.spi.project.ui.ProjectOpenedHook;
121	import org.netbeans.spi.project.ui.RecommendedTemplates;	118	import org.netbeans.spi.project.ui.RecommendedTemplates;
Lines 294-311 Link Here
294		291
295	private Lookup createLookup(AuxiliaryConfiguration aux, ClassPathProviderImpl cpProvider) {	292	private Lookup createLookup(AuxiliaryConfiguration aux, ClassPathProviderImpl cpProvider) {
296	SubprojectProvider spp = refHelper.createSubprojectProvider();	293	SubprojectProvider spp = refHelper.createSubprojectProvider();
297
298	final SourcesHelper sourcesHelper = new SourcesHelper(helper, evaluator());
299	String configFilesLabel = NbBundle.getMessage(AppClientLogicalViewProvider.class, "LBL_Node_ConfFiles"); //NOI18N
300
301	//sourcesHelper.addPrincipalSourceRoot("${"+AppClientProjectProperties.SOURCE_ROOT+"}", ejbModuleLabel, /XXX/null, null);
302	sourcesHelper.addPrincipalSourceRoot("${"+AppClientProjectProperties.META_INF+"}", configFilesLabel, /XXX/null, null); // NOI18N
303
304	ProjectManager.mutex().postWriteRequest(new Runnable() {
305	public void run() {
306	sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
307	}
308	});
309	FileEncodingQueryImplementation encodingQuery = QuerySupport.createFileEncodingQuery(evaluator(), AppClientProjectProperties.SOURCE_ENCODING);	294	FileEncodingQueryImplementation encodingQuery = QuerySupport.createFileEncodingQuery(evaluator(), AppClientProjectProperties.SOURCE_ENCODING);
310	Lookup base = Lookups.fixed(new Object[] {	295	Lookup base = Lookups.fixed(new Object[] {
311	new Info(),	296	new Info(),
Lines 325-331 Link Here
325	UILookupMergerSupport.createProjectOpenHookMerger(new ProjectOpenedHookImpl()),	310	UILookupMergerSupport.createProjectOpenHookMerger(new ProjectOpenedHookImpl()),
326	QuerySupport.createUnitTestForSourceQuery(getSourceRoots(),getTestSourceRoots()),	311	QuerySupport.createUnitTestForSourceQuery(getSourceRoots(),getTestSourceRoots()),
327	QuerySupport.createSourceLevelQuery(evaluator()),	312	QuerySupport.createSourceLevelQuery(evaluator()),
328	new AppClientSources(this.helper, evaluator(), getSourceRoots(), getTestSourceRoots()),	313	new AppClientSources(this, helper, evaluator(), getSourceRoots(), getTestSourceRoots()),
329	QuerySupport.createSharabilityQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots(),	314	QuerySupport.createSharabilityQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots(),
330	AppClientProjectProperties.META_INF),	315	AppClientProjectProperties.META_INF),
331	QuerySupport.createFileBuiltQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()),	316	QuerySupport.createFileBuiltQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()),

Lines 52-61 Link Here

(-)a/j2ee.earproject/src/org/netbeans/modules/j2ee/earproject/EarProject.java (-16 / +1 lines)
52	import java.util.logging.Level;	52	import java.util.logging.Level;
53	import java.util.logging.Logger;	53	import java.util.logging.Logger;
54	import javax.swing.Icon;	54	import javax.swing.Icon;
55	import javax.swing.ImageIcon;
56	import org.netbeans.api.java.classpath.ClassPath;	55	import org.netbeans.api.java.classpath.ClassPath;
57	import org.netbeans.api.java.classpath.GlobalPathRegistry;	56	import org.netbeans.api.java.classpath.GlobalPathRegistry;
58	import org.netbeans.api.project.FileOwnerQuery;
59	import org.netbeans.api.project.Project;	57	import org.netbeans.api.project.Project;
60	import org.netbeans.api.project.ProjectInformation;	58	import org.netbeans.api.project.ProjectInformation;
61	import org.netbeans.api.project.ProjectManager;	59	import org.netbeans.api.project.ProjectManager;
Lines 97-103 Link Here
97	import org.netbeans.spi.project.support.ant.PropertyEvaluator;	95	import org.netbeans.spi.project.support.ant.PropertyEvaluator;
98	import org.netbeans.spi.project.support.ant.PropertyUtils;	96	import org.netbeans.spi.project.support.ant.PropertyUtils;
99	import org.netbeans.spi.project.support.ant.ReferenceHelper;	97	import org.netbeans.spi.project.support.ant.ReferenceHelper;
100	import org.netbeans.spi.project.support.ant.SourcesHelper;
101	import org.netbeans.spi.project.ui.PrivilegedTemplates;	98	import org.netbeans.spi.project.ui.PrivilegedTemplates;
102	import org.netbeans.spi.project.ui.ProjectOpenedHook;	99	import org.netbeans.spi.project.ui.ProjectOpenedHook;
103	import org.netbeans.spi.project.ui.RecommendedTemplates;	100	import org.netbeans.spi.project.ui.RecommendedTemplates;
Lines 206-223 Link Here
206		203
207	private Lookup createLookup(AuxiliaryConfiguration aux, ClassPathProviderImpl cpProvider) {	204	private Lookup createLookup(AuxiliaryConfiguration aux, ClassPathProviderImpl cpProvider) {
208	SubprojectProvider spp = refHelper.createSubprojectProvider();	205	SubprojectProvider spp = refHelper.createSubprojectProvider();
209
210	// XXX unnecessarily creates a SourcesHelper, which is then GC's
211	// as it is not hold. This is probably unneeded now that issue 63359 was fixed.
212	final SourcesHelper sourcesHelper = new SourcesHelper(helper, evaluator());
213	String configFilesLabel = NbBundle.getMessage(EarProject.class, "LBL_Node_ConfigBase"); //NOI18N
214
215	sourcesHelper.addPrincipalSourceRoot("${"+EarProjectProperties.META_INF+"}", configFilesLabel, /XXX/null, null); // NOI18N
216	ProjectManager.mutex().postWriteRequest(new Runnable() {
217	public void run() {
218	sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
219	}
220	});
221	Lookup base = Lookups.fixed(new Object[] {	206	Lookup base = Lookups.fixed(new Object[] {
222	new Info(),	207	new Info(),
223	aux,	208	aux,
Lines 232-238 Link Here
232	LookupMergerSupport.createClassPathProviderMerger(cpProvider),	217	LookupMergerSupport.createClassPathProviderMerger(cpProvider),
233	new ProjectXmlSavedHookImpl(),	218	new ProjectXmlSavedHookImpl(),
234	UILookupMergerSupport.createProjectOpenHookMerger(new ProjectOpenedHookImpl()),	219	UILookupMergerSupport.createProjectOpenHookMerger(new ProjectOpenedHookImpl()),
235	new EarSources(helper, evaluator()),	220	new EarSources(this, helper, evaluator()),
236	new RecommendedTemplatesImpl(),	221	new RecommendedTemplatesImpl(),
237	helper.createSharabilityQuery(evaluator(),	222	helper.createSharabilityQuery(evaluator(),
238	new String[] {"${"+EarProjectProperties.SOURCE_ROOT+"}"}, // NOI18N	223	new String[] {"${"+EarProjectProperties.SOURCE_ROOT+"}"}, // NOI18N

Lines 62-74 Link Here

(-)a/j2ee.ejbjarproject/src/org/netbeans/modules/j2ee/ejbjarproject/EjbJarProject.java (-17 / +1 lines)
62	import java.util.logging.Level;	62	import java.util.logging.Level;
63	import java.util.logging.Logger;	63	import java.util.logging.Logger;
64	import javax.swing.Icon;	64	import javax.swing.Icon;
65	import javax.swing.ImageIcon;
66	import javax.swing.JButton;	65	import javax.swing.JButton;
67	import javax.swing.SwingUtilities;	66	import javax.swing.SwingUtilities;
68	import org.netbeans.api.java.classpath.ClassPath;	67	import org.netbeans.api.java.classpath.ClassPath;
69	import org.netbeans.api.java.classpath.GlobalPathRegistry;	68	import org.netbeans.api.java.classpath.GlobalPathRegistry;
70	import org.netbeans.api.java.project.JavaProjectConstants;	69	import org.netbeans.api.java.project.JavaProjectConstants;
71	import org.netbeans.api.project.FileOwnerQuery;
72	import org.netbeans.api.project.Project;	70	import org.netbeans.api.project.Project;
73	import org.netbeans.api.project.ProjectManager;	71	import org.netbeans.api.project.ProjectManager;
74	import org.netbeans.api.project.ant.AntArtifact;	72	import org.netbeans.api.project.ant.AntArtifact;
Lines 116-122 Link Here
116	import org.netbeans.spi.project.ui.RecommendedTemplates;	114	import org.netbeans.spi.project.ui.RecommendedTemplates;
117	import org.netbeans.spi.project.support.ant.ReferenceHelper;	115	import org.netbeans.spi.project.support.ant.ReferenceHelper;
118	import org.netbeans.spi.project.support.ant.PropertyEvaluator;	116	import org.netbeans.spi.project.support.ant.PropertyEvaluator;
119	import org.netbeans.spi.project.support.ant.SourcesHelper;
120	import org.netbeans.spi.project.ui.ProjectOpenedHook;	117	import org.netbeans.spi.project.ui.ProjectOpenedHook;
121	import org.openide.filesystems.FileChangeListener;	118	import org.openide.filesystems.FileChangeListener;
122	import org.openide.filesystems.FileObject;	119	import org.openide.filesystems.FileObject;
Lines 400-418 Link Here
400		397
401	private Lookup createLookup(AuxiliaryConfiguration aux, ClassPathProviderImpl cpProvider) {	398	private Lookup createLookup(AuxiliaryConfiguration aux, ClassPathProviderImpl cpProvider) {
402	SubprojectProvider spp = refHelper.createSubprojectProvider();	399	SubprojectProvider spp = refHelper.createSubprojectProvider();
403
404	final SourcesHelper sourcesHelper = new SourcesHelper(helper, evaluator());
405	String ejbModuleLabel = org.openide.util.NbBundle.getMessage(EjbJarLogicalViewProvider.class, "LBL_Node_EJBModule"); //NOI18N
406	String configFilesLabel = org.openide.util.NbBundle.getMessage(EjbJarLogicalViewProvider.class, "LBL_Node_DocBase"); //NOI18N
407
408	sourcesHelper.addPrincipalSourceRoot("${"+EjbJarProjectProperties.SOURCE_ROOT+"}", ejbModuleLabel, /XXX/null, null);
409	sourcesHelper.addPrincipalSourceRoot("${"+EjbJarProjectProperties.META_INF+"}", configFilesLabel, /XXX/null, null);
410
411	ProjectManager.mutex().postWriteRequest(new Runnable() {
412	public void run() {
413	sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
414	}
415	});
416	FileEncodingQueryImplementation encodingQuery = QuerySupport.createFileEncodingQuery(evaluator(), EjbJarProjectProperties.SOURCE_ENCODING);	400	FileEncodingQueryImplementation encodingQuery = QuerySupport.createFileEncodingQuery(evaluator(), EjbJarProjectProperties.SOURCE_ENCODING);
417	Lookup base = Lookups.fixed(new Object[] {	401	Lookup base = Lookups.fixed(new Object[] {
418	EjbJarProject.this, // never cast an externally obtained Project to EjbJarProject - use lookup instead	402	EjbJarProject.this, // never cast an externally obtained Project to EjbJarProject - use lookup instead
Lines 437-443 Link Here
437	UILookupMergerSupport.createProjectOpenHookMerger(new ProjectOpenedHookImpl()),	421	UILookupMergerSupport.createProjectOpenHookMerger(new ProjectOpenedHookImpl()),
438	QuerySupport.createUnitTestForSourceQuery(getSourceRoots(), getTestSourceRoots()),	422	QuerySupport.createUnitTestForSourceQuery(getSourceRoots(), getTestSourceRoots()),
439	QuerySupport.createSourceLevelQuery(evaluator()),	423	QuerySupport.createSourceLevelQuery(evaluator()),
440	new EjbJarSources (helper, evaluator(), getSourceRoots(), getTestSourceRoots()),	424	new EjbJarSources(this, helper, evaluator(), getSourceRoots(), getTestSourceRoots()),
441	QuerySupport.createSharabilityQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots(),	425	QuerySupport.createSharabilityQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots(),
442	EjbJarProjectProperties.META_INF),	426	EjbJarProjectProperties.META_INF),
443	QuerySupport.createFileBuiltQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()),	427	QuerySupport.createFileBuiltQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()),

Lines 156-162 Link Here

(-)a/java.j2seproject/src/org/netbeans/modules/java/j2seproject/J2SEProject.java (-2 / +3 lines)
156	private final PropertyEvaluator eval;	156	private final PropertyEvaluator eval;
157	private final ReferenceHelper refHelper;	157	private final ReferenceHelper refHelper;
158	private final GeneratedFilesHelper genFilesHelper;	158	private final GeneratedFilesHelper genFilesHelper;
159	private final Lookup lookup;	159	private Lookup lookup;
160	private final UpdateHelper updateHelper;	160	private final UpdateHelper updateHelper;
161	private MainClassUpdater mainClassUpdater;	161	private MainClassUpdater mainClassUpdater;
162	private SourceRoots sourceRoots;	162	private SourceRoots sourceRoots;
Lines 313-319 Link Here
313	UILookupMergerSupport.createProjectOpenHookMerger(new ProjectOpenedHookImpl()),	313	UILookupMergerSupport.createProjectOpenHookMerger(new ProjectOpenedHookImpl()),
314	QuerySupport.createUnitTestForSourceQuery(getSourceRoots(), getTestSourceRoots()),	314	QuerySupport.createUnitTestForSourceQuery(getSourceRoots(), getTestSourceRoots()),
315	QuerySupport.createSourceLevelQuery(evaluator()),	315	QuerySupport.createSourceLevelQuery(evaluator()),
316	new J2SESources (this.helper, evaluator(), getSourceRoots(), getTestSourceRoots()),	316	new J2SESources(this, helper, evaluator(), getSourceRoots(), getTestSourceRoots()),
317	QuerySupport.createSharabilityQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()),	317	QuerySupport.createSharabilityQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()),
318	new CoSAwareFileBuiltQueryImpl(QuerySupport.createFileBuiltQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()), this),	318	new CoSAwareFileBuiltQueryImpl(QuerySupport.createFileBuiltQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()), this),
319	new RecommendedTemplatesImpl (this.updateHelper),	319	new RecommendedTemplatesImpl (this.updateHelper),
Lines 335-340 Link Here
335	LookupMergerSupport.createJFBLookupMerger(),	335	LookupMergerSupport.createJFBLookupMerger(),
336	QuerySupport.createBinaryForSourceQueryImplementation(this.sourceRoots, this.testRoots, this.helper, this.eval) //Does not use APH to get/put properties/cfgdata	336	QuerySupport.createBinaryForSourceQueryImplementation(this.sourceRoots, this.testRoots, this.helper, this.eval) //Does not use APH to get/put properties/cfgdata
337	);	337	);
		338	lookup = base; // in case LookupProvider's call Project.getLookup
338	return LookupProviderSupport.createCompositeLookup(base, "Projects/org-netbeans-modules-java-j2seproject/Lookup"); //NOI18N	339	return LookupProviderSupport.createCompositeLookup(base, "Projects/org-netbeans-modules-java-j2seproject/Lookup"); //NOI18N
339	}	340	}
340		341

Lines 104-109 Link Here

(-)a/project.ant/apichanges.xml (+16 lines)
104	<!-- ACTUAL CHANGES BEGIN HERE: -->	104	<!-- ACTUAL CHANGES BEGIN HERE: -->
105		105
106	<changes>	106	<changes>
		107
		108	<change id="SourcesHelper-Project-constructor">
		109	<api name="general"/>
		110	<summary>Added <code>SourcesHelper</code> constructor accepting <code>Project</code></summary>
		111	<version major="1" minor="31"/>
		112	<date day="27" month="3" year="2009"/>
		113	<author login="tzezula"/>
		114	<compatibility addition="yes" deprecation="yes"/>
		115	<description>
		116	<p>
		117	The new constructor enables simplified control flow.
		118	</p>
		119	</description>
		120	<class package="org.netbeans.spi.project.support.ant" name="SourcesHelper"/>
		121	<issue number="146852"/>
		122	</change>
107		123
108	<change id="antbasedprojectregistration">	124	<change id="antbasedprojectregistration">
109	<api name="general"/>	125	<api name="general"/>

Lines 74-79 Link Here

(-)a/project.ant/src/org/netbeans/spi/project/support/ant/SourcesHelper.java (-9 / +32 lines)
74	import org.openide.filesystems.FileStateInvalidException;	74	import org.openide.filesystems.FileStateInvalidException;
75	import org.openide.filesystems.FileUtil;	75	import org.openide.filesystems.FileUtil;
76	import org.openide.util.ChangeSupport;	76	import org.openide.util.ChangeSupport;
		77	import org.openide.util.Parameters;
77	import org.openide.util.WeakListeners;	78	import org.openide.util.WeakListeners;
78		79
79	// XXX should perhaps be legal to call add* methods at any time (should update things)	80	// XXX should perhaps be legal to call add* methods at any time (should update things)
Lines 98-104 Link Here
98	if (val == null) {	99	if (val == null) {
99	return null;	100	return null;
100	}	101	}
101	return project.resolveFile(val);	102	return aph.resolveFile(val);
102	}	103	}
103	public Collection<FileObject> getIncludeRoots(boolean minimalSubfolders) {	104	public Collection<FileObject> getIncludeRoots(boolean minimalSubfolders) {
104	File loc = getActualLocation();	105	File loc = getActualLocation();
Lines 292-298 Link Here
292	}	293	}
293	}	294	}
294		295
295	private final AntProjectHelper project;	296	private final AntProjectHelper aph;
		297	private final Project project;
296	private final PropertyEvaluator evaluator;	298	private final PropertyEvaluator evaluator;
297	private final List<SourceRoot> principalSourceRoots = new ArrayList<SourceRoot>();	299	private final List<SourceRoot> principalSourceRoots = new ArrayList<SourceRoot>();
298	private final List<Root> nonSourceRoots = new ArrayList<Root>();	300	private final List<Root> nonSourceRoots = new ArrayList<Root>();
Lines 312-322 Link Here
312	/**	314	/**
313	* Create the helper object, initially configured to recognize only sources	315	* Create the helper object, initially configured to recognize only sources
314	* contained inside the project directory.	316	* contained inside the project directory.
315	* @param project an Ant project helper	317	* @param aph an Ant project helper
316	* @param evaluator a way to evaluate Ant properties used to define source locations	318	* @param evaluator a way to evaluate Ant properties used to define source locations
		319	* @deprecated Rather use {@link #SourcesHelper(Project, AntProjectHelper, PropertyEvaluator)}.
317	*/	320	*/
318	public SourcesHelper(AntProjectHelper project, PropertyEvaluator evaluator) {	321	@Deprecated
		322	public SourcesHelper(AntProjectHelper aph, PropertyEvaluator evaluator) {
		323	this.project = null;
		324	this.aph = aph;
		325	this.evaluator = evaluator;
		326	}
		327
		328	/**
		329	* Create the helper object, initially configured to recognize only sources
		330	* contained inside the project directory.
		331	* @param project the project object (need not yet be registered in {@link ProjectManager})
		332	* @param aph an Ant project helper
		333	* @param evaluator a way to evaluate Ant properties used to define source locations
		334	* @since org.netbeans.modules.project.ant/1 1.31
		335	*/
		336	public SourcesHelper(Project project, AntProjectHelper aph, PropertyEvaluator evaluator) {
		337	Parameters.notNull("project", project);
319	this.project = project;	338	this.project = project;
		339	this.aph = aph;
320	this.evaluator = evaluator;	340	this.evaluator = evaluator;
321	}	341	}
322		342
Lines 470-476 Link Here
470	}	490	}
471		491
472	private Project getProject() {	492	private Project getProject() {
473	return AntBasedProjectFactorySingleton.getProjectFor(project);	493	return project != null ? project : AntBasedProjectFactorySingleton.getProjectFor(aph);
474	}	494	}
475		495
476	/**	496	/**
Lines 504-514 Link Here
504	* {@link FileOwnerQuery#EXTERNAL_ALGORITHM_TRANSIENT}.	524	* {@link FileOwnerQuery#EXTERNAL_ALGORITHM_TRANSIENT}.
505	* </p>	525	* </p>
506	* <p>	526	* <p>
507	* You may <em>not</em> call this method inside the project's constructor, as	527	* If you used the old constructor form
508	* it requires the actual project to exist and be registered in {@link ProjectManager}.	528	* {@link #SourcesHelper(AntProjectHelper, PropertyEvaluator)}
509	* Typically you would use {@link org.openide.util.Mutex#postWriteRequest} to run it	529	* then you may <em>not</em> call this method inside the project's constructor, as
		530	* it requires the actual project to exist and be registered in {@link ProjectManager};
		531	* in this case you could still use {@link org.openide.util.Mutex#postWriteRequest} to run it
510	* later, if you were creating the helper in your constructor, since the project construction	532	* later, if you were creating the helper in your constructor, since the project construction
511	* normally occurs in read access.	533	* normally occurs in read access.
		534	* Better to use {@link #SourcesHelper(Project, AntProjectHelper, PropertyEvaluator)}.
512	* </p>	535	* </p>
513	* @param algorithm an external root registration algorithm as per	536	* @param algorithm an external root registration algorithm as per
514	* {@link FileOwnerQuery#markExternalOwner}	537	* {@link FileOwnerQuery#markExternalOwner}
Lines 584-590 Link Here
584	allRoots.addAll(nonSourceRoots);	607	allRoots.addAll(nonSourceRoots);
585	allRoots.addAll(ownedFiles);	608	allRoots.addAll(ownedFiles);
586	Project p = getProject();	609	Project p = getProject();
587	FileObject pdir = project.getProjectDirectory();	610	FileObject pdir = aph.getProjectDirectory();
588	// First time: register roots and add to lastRegisteredRoots.	611	// First time: register roots and add to lastRegisteredRoots.
589	// Subsequent times: add to newRootsToRegister and maybe add them later.	612	// Subsequent times: add to newRootsToRegister and maybe add them later.
590	if (lastRegisteredRoots == null) {	613	if (lastRegisteredRoots == null) {

Lines 85-91 Link Here

(-)a/project.ant/test/unit/src/org/netbeans/spi/project/support/ant/SourcesHelperTest.java (-6 / +6 lines)
85	private Project project2;	85	private Project project2;
86	private SourcesHelper sh2;	86	private SourcesHelper sh2;
87		87
88	protected void setUp() throws Exception {	88	protected @Override void setUp() throws Exception {
89	super.setUp();	89	super.setUp();
90	MockLookup.setInstances(AntBasedTestUtil.testAntBasedProjectType());	90	MockLookup.setInstances(AntBasedTestUtil.testAntBasedProjectType());
91	scratch = TestUtil.makeScratchDir(this);	91	scratch = TestUtil.makeScratchDir(this);
Lines 120-126 Link Here
120	p.setProperty("ext.file", "../../external/extFile");	120	p.setProperty("ext.file", "../../external/extFile");
121	h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);	121	h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);
122	ProjectManager.getDefault().saveProject(project);	122	ProjectManager.getDefault().saveProject(project);
123	sh = new SourcesHelper(h, h.getStandardPropertyEvaluator());	123	sh = new SourcesHelper(project, h, h.getStandardPropertyEvaluator());
124	sh.addPrincipalSourceRoot("${src1.dir}", "Sources #1", null, null); // inside proj dir	124	sh.addPrincipalSourceRoot("${src1.dir}", "Sources #1", null, null); // inside proj dir
125	sh.addPrincipalSourceRoot("${src2.dir}", "Sources #2", null, null); // outside (rel path)	125	sh.addPrincipalSourceRoot("${src2.dir}", "Sources #2", null, null); // outside (rel path)
126	sh.addPrincipalSourceRoot("${src2a.dir}", "Sources #2a", null, null); // redundant	126	sh.addPrincipalSourceRoot("${src2a.dir}", "Sources #2a", null, null); // redundant
Lines 147-153 Link Here
147	h2 = ProjectGenerator.createProject(proj2dir, "test");	147	h2 = ProjectGenerator.createProject(proj2dir, "test");
148	project2 = ProjectManager.getDefault().findProject(proj2dir);	148	project2 = ProjectManager.getDefault().findProject(proj2dir);
149	assertNotNull("have a project2", project2);	149	assertNotNull("have a project2", project2);
150	sh2 = new SourcesHelper(h2, h2.getStandardPropertyEvaluator());	150	sh2 = new SourcesHelper(project2, h2, h2.getStandardPropertyEvaluator());
151	sh2.addPrincipalSourceRoot("src1", "Sources #1", null, null);	151	sh2.addPrincipalSourceRoot("src1", "Sources #1", null, null);
152	sh2.addPrincipalSourceRoot("src2", "Sources #2", null, null);	152	sh2.addPrincipalSourceRoot("src2", "Sources #2", null, null);
153	sh2.addNonSourceRoot("build");	153	sh2.addNonSourceRoot("build");
Lines 420-426 Link Here
420	// <editor-fold desc="other setup #2">	420	// <editor-fold desc="other setup #2">
421	h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);	421	h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);
422	ProjectManager.getDefault().saveProject(project);	422	ProjectManager.getDefault().saveProject(project);
423	sh = new SourcesHelper(h, h.getStandardPropertyEvaluator());	423	sh = new SourcesHelper(project, h, h.getStandardPropertyEvaluator());
424	sh.addPrincipalSourceRoot("${src1.dir}", "${src1.includes}", "${src1.excludes}", "Sources #1", null, null);	424	sh.addPrincipalSourceRoot("${src1.dir}", "${src1.includes}", "${src1.excludes}", "Sources #1", null, null);
425	sh.addPrincipalSourceRoot("${src2.dir}", "${src2.includes}", "${src2.excludes}", "Sources #2", null, null);	425	sh.addPrincipalSourceRoot("${src2.dir}", "${src2.includes}", "${src2.excludes}", "Sources #2", null, null);
426	sh.addPrincipalSourceRoot("${src3.dir}", "${src3.includes}", null, "Sources #3", null, null);	426	sh.addPrincipalSourceRoot("${src3.dir}", "${src3.includes}", null, "Sources #3", null, null);
Lines 594-600 Link Here
594	h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);	594	h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);
595	ProjectManager.getDefault().saveProject(project);	595	ProjectManager.getDefault().saveProject(project);
596	//minimalSubfolders = true	596	//minimalSubfolders = true
597	sh = new SourcesHelper(h, h.getStandardPropertyEvaluator());	597	sh = new SourcesHelper(project, h, h.getStandardPropertyEvaluator());
598	sh.addPrincipalSourceRoot("${src1.dir}", "${src1.includes}", "${src1.excludes}", "Sources #1", null, null);	598	sh.addPrincipalSourceRoot("${src1.dir}", "${src1.includes}", "${src1.excludes}", "Sources #1", null, null);
599	sh.addTypedSourceRoot("${src1.dir}", "${src1.includes}", "${src1.excludes}", "java", "Packages #1", null, null);	599	sh.addTypedSourceRoot("${src1.dir}", "${src1.includes}", "${src1.excludes}", "java", "Packages #1", null, null);
600	sh.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT, true);	600	sh.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT, true);
Lines 604-610 Link Here
604	assertEquals("Packages #1", g1.getDisplayName());	604	assertEquals("Packages #1", g1.getDisplayName());
605	assertNull(FileOwnerQuery.getOwner(src1dir));	605	assertNull(FileOwnerQuery.getOwner(src1dir));
606	//minimalSubfolders = false	606	//minimalSubfolders = false
607	sh = new SourcesHelper(h, h.getStandardPropertyEvaluator());	607	sh = new SourcesHelper(project, h, h.getStandardPropertyEvaluator());
608	sh.addPrincipalSourceRoot("${src1.dir}", "${src1.includes}", "${src1.excludes}", "Sources #1", null, null);	608	sh.addPrincipalSourceRoot("${src1.dir}", "${src1.includes}", "${src1.excludes}", "Sources #1", null, null);
609	sh.addTypedSourceRoot("${src1.dir}", "${src1.includes}", "${src1.excludes}", "java", "Packages #1", null, null);	609	sh.addTypedSourceRoot("${src1.dir}", "${src1.includes}", "${src1.excludes}", "java", "Packages #1", null, null);
610	sh.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT, false);	610	sh.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT, false);

Lines 40-70 Link Here

(-)a/projectimport.eclipse.core/src/org/netbeans/modules/projectimport/eclipse/core/ProjectOpenHookImpl.java (-15 / +1 lines)
40	package org.netbeans.modules.projectimport.eclipse.core;	40	package org.netbeans.modules.projectimport.eclipse.core;
41		41
42	import java.util.concurrent.ExecutionException;	42	import java.util.concurrent.ExecutionException;
43	import java.util.logging.Logger;
44	import org.netbeans.api.project.Project;
45	import org.netbeans.api.project.ui.OpenProjects;	43	import org.netbeans.api.project.ui.OpenProjects;
46	import org.netbeans.spi.project.ui.ProjectOpenedHook;	44	import org.netbeans.spi.project.ui.ProjectOpenedHook;
47	import org.openide.util.Exceptions;	45	import org.openide.util.Exceptions;
48	import org.openide.util.RequestProcessor;	46	import org.openide.util.RequestProcessor;
49		47
50	/**
51	*
52	*/
53	public class ProjectOpenHookImpl extends ProjectOpenedHook{	48	public class ProjectOpenHookImpl extends ProjectOpenedHook{
54		49
55	private static final RequestProcessor PROJ_OPEN_HOOK_RESYNCHRONIZER = new RequestProcessor("Eclipse.Resynchronizer"); // NOI18N	50	private static final RequestProcessor PROJ_OPEN_HOOK_RESYNCHRONIZER = new RequestProcessor("Eclipse.Resynchronizer"); // NOI18N
56	private static RequestProcessor.Task currentTask;	51	private static RequestProcessor.Task currentTask;
57		52
58	private UpgradableProject upgradable;	53	public ProjectOpenHookImpl() {}
59	private Project project;
60
61	private static final Logger LOG =
62	Logger.getLogger(ProjectOpenHookImpl.class.getName());
63
64	public ProjectOpenHookImpl(Project project, UpgradableProject upgradable) {
65	this.upgradable = upgradable;
66	this.project = project;
67	}
68		54
69	@Override	55	@Override
70	protected synchronized void projectOpened() {	56	protected synchronized void projectOpened() {

Lines 46-52 Link Here

(-)a/projectimport.eclipse.core/test/unit/src/org/netbeans/modules/projectimport/eclipse/core/spi/ProjectFactorySupportTest.java (-33 lines)
46	import java.util.Collections;	46	import java.util.Collections;
47	import java.util.List;	47	import java.util.List;
48	import org.netbeans.api.java.platform.JavaPlatform;	48	import org.netbeans.api.java.platform.JavaPlatform;
49	import org.netbeans.api.project.FileOwnerQuery;
50	import org.netbeans.api.project.Project;	49	import org.netbeans.api.project.Project;
51	import org.netbeans.api.project.ProjectManager;	50	import org.netbeans.api.project.ProjectManager;
52	import org.netbeans.api.project.ProjectUtils;	51	import org.netbeans.api.project.ProjectUtils;
Lines 225-238 Link Here
225	model.getEclipseTestSourceRootsAsFileArray(), null, null, null);	224	model.getEclipseTestSourceRootsAsFileArray(), null, null, null);
226	J2SEProject p = (J2SEProject)ProjectManager.getDefault().findProject(helper.getProjectDirectory());	225	J2SEProject p = (J2SEProject)ProjectManager.getDefault().findProject(helper.getProjectDirectory());
227	List<String> importProblems = new ArrayList<String>();	226	List<String> importProblems = new ArrayList<String>();
228
229	//
230	// NB-Core-Build #1293: "No project found to correspond to .../spcp/eclipse/src" from ProjectClassPathModifier.findExtensible
231	//
232	// Looks like J2SEProject registers its external source roots asynchronously and sometimes
233	// it is too late and above problem happens. Mark external source roots explicitly here:
234	FileOwnerQuery.markExternalOwner(model.getEclipseSourceRootsAsFileArray()[0].toURI(), p, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
235
236	ProjectFactorySupport.updateProjectClassPath(helper, p.getReferenceHelper(), model, importProblems);	227	ProjectFactorySupport.updateProjectClassPath(helper, p.getReferenceHelper(), model, importProblems);
237	EditableProperties ep = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);	228	EditableProperties ep = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
238	assertEquals(	229	assertEquals(
Lines 262-275 Link Here
262	model.getEclipseTestSourceRootsAsFileArray(), null, null, null);	253	model.getEclipseTestSourceRootsAsFileArray(), null, null, null);
263	J2SEProject p = (J2SEProject)ProjectManager.getDefault().findProject(helper.getProjectDirectory());	254	J2SEProject p = (J2SEProject)ProjectManager.getDefault().findProject(helper.getProjectDirectory());
264	List<String> importProblems = new ArrayList<String>();	255	List<String> importProblems = new ArrayList<String>();
265
266	//
267	// NB-Core-Build #1293: "No project found to correspond to .../spcp/eclipse/src" from ProjectClassPathModifier.findExtensible
268	//
269	// Looks like J2SEProject registers its external source roots asynchronously and sometimes
270	// it is too late and above problem happens. Mark external source roots explicitly here:
271	FileOwnerQuery.markExternalOwner(model.getEclipseSourceRootsAsFileArray()[0].toURI(), p, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
272
273	ProjectFactorySupport.updateProjectClassPath(helper, p.getReferenceHelper(), model, importProblems);	256	ProjectFactorySupport.updateProjectClassPath(helper, p.getReferenceHelper(), model, importProblems);
274	EditableProperties ep = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);	257	EditableProperties ep = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
275	assertEquals(	258	assertEquals(
Lines 355-368 Link Here
355	model.getEclipseTestSourceRootsAsFileArray(), null, null, null);	338	model.getEclipseTestSourceRootsAsFileArray(), null, null, null);
356	J2SEProject p = (J2SEProject)ProjectManager.getDefault().findProject(helper.getProjectDirectory());	339	J2SEProject p = (J2SEProject)ProjectManager.getDefault().findProject(helper.getProjectDirectory());
357	List<String> importProblems = new ArrayList<String>();	340	List<String> importProblems = new ArrayList<String>();
358
359	//
360	// NB-Core-Build #1293: "No project found to correspond to .../spcp/eclipse/src" from ProjectClassPathModifier.findExtensible
361	//
362	// Looks like J2SEProject registers its external source roots asynchronously and sometimes
363	// it is too late and above problem happens. Mark external source roots explicitly here:
364	FileOwnerQuery.markExternalOwner(model.getEclipseSourceRootsAsFileArray()[0].toURI(), p, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
365
366	ProjectFactorySupport.updateProjectClassPath(helper, p.getReferenceHelper(), model, importProblems);	341	ProjectFactorySupport.updateProjectClassPath(helper, p.getReferenceHelper(), model, importProblems);
367	EditableProperties ep = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);	342	EditableProperties ep = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
368	// required project "JavaLibrary1" is not available and therefore should not be	343	// required project "JavaLibrary1" is not available and therefore should not be
Lines 411-424 Link Here
411	mdl_d.getEclipseTestSourceRootsAsFileArray(), null, null, null);	386	mdl_d.getEclipseTestSourceRootsAsFileArray(), null, null, null);
412	List<String> problems = new ArrayList<String>();	387	List<String> problems = new ArrayList<String>();
413	J2SEProject j2seprj_d = (J2SEProject) ProjectManager.getDefault().findProject(aph_d.getProjectDirectory());	388	J2SEProject j2seprj_d = (J2SEProject) ProjectManager.getDefault().findProject(aph_d.getProjectDirectory());
414
415	//
416	// NB-Core-Build #1293: "No project found to correspond to .../spcp/eclipse/src" from ProjectClassPathModifier.findExtensible
417	//
418	// Looks like J2SEProject registers its external source roots asynchronously and sometimes
419	// it is too late and above problem happens. Mark external source roots explicitly here:
420	FileOwnerQuery.markExternalOwner(mdl_d.getEclipseSourceRootsAsFileArray()[0].toURI(), j2seprj_d, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
421
422	ProjectFactorySupport.updateProjectClassPath(aph_d, j2seprj_d.getReferenceHelper(), mdl_d, problems);	389	ProjectFactorySupport.updateProjectClassPath(aph_d, j2seprj_d.getReferenceHelper(), mdl_d, problems);
423	assertEquals(Collections.emptyList(), problems);	390	assertEquals(Collections.emptyList(), problems);
424	assertEquals("${reference.c.jar}:${reference.b.jar}", aph_d.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH).get("javac.classpath"));	391	assertEquals("${reference.c.jar}:${reference.b.jar}", aph_d.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH).get("javac.classpath"));