Attachment #79235 for bug #161120

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

Lines 112-118 Link Here

(-)a/apisupport.refactoring/nbproject/project.xml (-1 / +1 lines)
112	<compile-dependency/>	112	<compile-dependency/>
113	<run-dependency>	113	<run-dependency>
114	<release-version>1</release-version>	114	<release-version>1</release-version>
115	<specification-version>1.22</specification-version>	115	<specification-version>1.34</specification-version>
116	</run-dependency>	116	</run-dependency>
117	</dependency>	117	</dependency>
118	<dependency>	118	<dependency>




    public static boolean isFileInOpenProject(FileObject file) {
        assert file != null;
        Project p = FileOwnerQuery.getOwner(file);
        return OpenProjects.getDefault().isProjectOpen(p);
        for (int i = 0; i<opened.length; i++) {
            if (p.equals(opened[i]) || opened[i].equals(p)) {
                return true;
            }
        }
        return false;
    }
    
    public static boolean isOnSourceClasspath(FileObject fo) {

Lines 172-178 Link Here

(-)a/cnd.refactoring/nbproject/project.xml (-1 / +1 lines)
172	<compile-dependency/>	172	<compile-dependency/>
173	<run-dependency>	173	<run-dependency>
174	<release-version>1</release-version>	174	<release-version>1</release-version>
175	<specification-version>1.33</specification-version>	175	<specification-version>1.34</specification-version>
176	</run-dependency>	176	</run-dependency>
177	</dependency>	177	</dependency>
178	<dependency>	178	<dependency>




            return false;
        }
        Project p = FileOwnerQuery.getOwner(f);
        return OpenProjects.getDefault().isProjectOpen(p);
        for (int i = 0; i < opened.length; i++) {
            if (p.equals(opened[i]) || opened[i].equals(p)) {
                return true;
            }
        }
        return false;
    }

    public static boolean isRefactorable(FileObject fo) {




                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>0.7</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.modules.csl.api</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <release-version>0-1</release-version>
                        <specification-version>1.8</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>

                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.modules.csl.api</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <release-version>0-1</release-version>
                        <specification-version>1.8</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.modules.parsing.api</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>1.0</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.modules.java.project</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>

                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.modules.parsing.api</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>1.0</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.modules.projectapi</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>

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




    public static boolean isOnSourceClasspath(FileObject fo) {
        Project p = FileOwnerQuery.getOwner(fo);
        if (p==null) return false;
        if (OpenProjects.getDefault().isProjectOpen(p)) {
            SourceGroup[] gr = ProjectUtils.getSources(p).getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
            for (int j = 0; j < gr.length; j++) {
                if (fo==gr[j].getRootFolder()) return true;
                if (FileUtil.isParentOf(gr[j].getRootFolder(), fo))
                    return true;
                    if (FileUtil.isParentOf(gr[j].getRootFolder(), fo))
                        return true;
                }
                return false;
            }
            return false;
        }
        return false;
    }




import javax.xml.parsers.ParserConfigurationException;
import org.netbeans.api.project.ui.OpenProjects;
import org.openide.filesystems.FileUtil;
import org.openide.util.Mutex;
import org.xml.sax.SAXException;

/**

            }
            if (s != null) {
                try {
                    class FindProject implements Mutex.ExceptionAction<Project> {
                        ProjectState s;
                        
                        public Project run() throws IOException {
                            for (ProjectFactory pf : Lookup.getDefault().lookupAll(ProjectFactory.class)) {
                                Project p = pf.loadProject(getProjectDirectory(), s);
                                if (p != null) {
                                    return p;
                                }
                            }
                            return null;
                        }
                    }
                    FindProject findProject = new FindProject();
                    findProject.s = s;
                    Project p = ProjectManager.mutex().readAccess(findProject);
                    if (p == FeatureNonProject.this) {
                        throw new IllegalStateException("New project shall be found! " + p); // NOI18N
                    }

Lines 107-113 Link Here

(-)a/j2ee.jpa.refactoring/nbproject/project.xml (-1 / +1 lines)
107	<compile-dependency/>	107	<compile-dependency/>
108	<run-dependency>	108	<run-dependency>
109	<release-version>1</release-version>	109	<release-version>1</release-version>
110	<specification-version>1.24</specification-version>	110	<specification-version>1.34</specification-version>
111	</run-dependency>	111	</run-dependency>
112	</dependency>	112	</dependency>
113	<dependency>	113	<dependency>




    public static boolean isOnSourceClasspath(FileObject fo) {
        Project p = FileOwnerQuery.getOwner(fo);
        if (p==null) return false;
        if (OpenProjects.getDefault().isProjectOpen(p)) {
            SourceGroup[] gr = ProjectUtils.getSources(p).getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
            for (int j = 0; j < gr.length; j++) {
                if (fo==gr[j].getRootFolder()) return true;
                if (FileUtil.isParentOf(gr[j].getRootFolder(), fo))
                    return true;
                    if (FileUtil.isParentOf(gr[j].getRootFolder(), fo))
                        return true;
                }
                return false;
            }
            return false;
        }
        return false;
    }




    public static boolean isFileInOpenProject(FileObject file) {
        assert file != null;
        Project p = FileOwnerQuery.getOwner(file);
        return OpenProjects.getDefault().isProjectOpen(p);
        for (int i = 0; i<opened.length; i++) {
            if (p.equals(opened[i]) || opened[i].equals(p)) {
                return true;
            }
        }
        return false;
    }
    
    public static boolean isOnSourceClasspath(FileObject fo) {

Lines 107-113 Link Here

(-)a/php.refactoring/nbproject/project.xml (-1 / +1 lines)
107	<compile-dependency/>	107	<compile-dependency/>
108	<run-dependency>	108	<run-dependency>
109	<release-version>1</release-version>	109	<release-version>1</release-version>
110	<specification-version>1.30</specification-version>	110	<specification-version>1.34</specification-version>
111	</run-dependency>	111	</run-dependency>
112	</dependency>	112	</dependency>
113	<dependency>	113	<dependency>




    public static boolean isFileInOpenProject(FileObject file) {
        assert file != null;
        Project p = FileOwnerQuery.getOwner(file);
        return OpenProjects.getDefault().isProjectOpen(p);
        for (int i = 0; i < opened.length; i++) {
            if (p.equals(opened[i]) || opened[i].equals(p)) {
                return true;
            }
        }
        return false;
    }

    public static boolean isOnSourceClasspath(FileObject fo) {

Lines 114-123 Link Here

(-)a/projectui/test/unit/src/org/netbeans/modules/project/ui/OpenProjectListDuplicatesTest.java (-1 / +9 lines)
114	}	114	}
115		115
116	LOG.info("Before first open");	116	LOG.info("Before first open");
117	OpenProjects.getDefault().open(new Project[] { new Fake() }, false);	117	Fake f = new Fake();
		118	assertFalse("null is not open", OpenProjects.getDefault().isProjectOpen(null));
		119	OpenProjects.getDefault().open(new Project[] { f }, false);
		120	assertTrue("Fake is open", OpenProjects.getDefault().isProjectOpen(f));
		121	assertTrue("Fake is open, but real one is reported open too", OpenProjects.getDefault().isProjectOpen(p));
118	LOG.info("After first and Before 2nd open");	122	LOG.info("After first and Before 2nd open");
119	OpenProjects.getDefault().open(new Project[] { p }, false);	123	OpenProjects.getDefault().open(new Project[] { p }, false);
120	LOG.info("After 2nd open");	124	LOG.info("After 2nd open");
		125	assertTrue("Real one is open", OpenProjects.getDefault().isProjectOpen(p));
		126	assertTrue("Fake is open too", OpenProjects.getDefault().isProjectOpen(f));
121		127
122		128
123	List<Project> arr = Arrays.asList(OpenProjects.getDefault().openProjects().get());	129	List<Project> arr = Arrays.asList(OpenProjects.getDefault().openProjects().get());
Lines 129-134 Link Here
129	if (OpenProjects.getDefault().getOpenProjects().length != 0) {	135	if (OpenProjects.getDefault().getOpenProjects().length != 0) {
130	fail("All projects shall be closed: " + Arrays.asList(OpenProjects.getDefault().getOpenProjects()));	136	fail("All projects shall be closed: " + Arrays.asList(OpenProjects.getDefault().getOpenProjects()));
131	}	137	}
		138	assertFalse("No project is opened", OpenProjects.getDefault().isProjectOpen(p));
		139	assertFalse("No project is opened", OpenProjects.getDefault().isProjectOpen(f));
132		140
133	assertEquals("Close hook called", 1, TestProjectOpenedHookImpl.closed);	141	assertEquals("Close hook called", 1, TestProjectOpenedHookImpl.closed);
134	}	142	}




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

    <changes>
        <change id="isProjectOpen">
            <api name="general"/>
            <summary>Utility method OpenProjects.isProjectOpen</summary>
            <version major="1" minor="34"/>
            <date day="7" month="4" year="2009"/>
            <author login="jtulach"/>
            <compatibility addition="yes" binary="compatible" deletion="no" deprecation="no" modification="no" semantic="compatible" source="compatible"/>
            <description>
                <p>
                  It came to our attention that often users of <code>OpenProjects</code>
                  want to find out if their project is opened or not. To simplify
                  such code we offer a handy utility method.
                </p>
            </description>
            <class package="org.netbeans.api.project.ui" name="OpenProjects"/>
            <issue number="161120"/>
        </change>
        <change id="nodefactory-ann">
            <api name="general"/>
            <summary>Add annotation @NodeFactory.Registration</summary>

Lines 39-45 Link Here

(-)a/projectuiapi/nbproject/project.properties (-1 / +1 lines)
39		39
40	javac.compilerargs=-Xlint -Xlint:-serial	40	javac.compilerargs=-Xlint -Xlint:-serial
41	javac.source=1.5	41	javac.source=1.5
42	spec.version.base=1.33.0	42	spec.version.base=1.34.0
43	is.autoload=true	43	is.autoload=true
44	javadoc.arch=${basedir}/arch.xml	44	javadoc.arch=${basedir}/arch.xml
45	javadoc.apichanges=${basedir}/apichanges.xml	45	javadoc.apichanges=${basedir}/apichanges.xml




        trampoline.openAPI (projects,openSubprojects);
    }

    /** Finds out if the project is opened.
     * @param p the project to verify
     * @return true if this project is among open ones, false otherwise
     * @since 1.34
     */
    public boolean isProjectOpen(Project p) {
        if (p == null) {
            return false;
        }
        for (Project real : getOpenProjects()) {
            if (p.equals(real) || real.equals(p)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Closes given projects.
     * Acquires {@link org.netbeans.api.project.ProjectManager#mutex()} in the write mode.

Lines 132-137 Link Here

(-)a/refactoring.java/nbproject/project.xml (+1 lines)
132	<compile-dependency/>	132	<compile-dependency/>
133	<run-dependency>	133	<run-dependency>
134	<release-version>1</release-version>	134	<release-version>1</release-version>
		135	<specification-version>1.34</specification-version>
135	</run-dependency>	136	</run-dependency>
136	</dependency>	137	</dependency>
137	<dependency>	138	<dependency>




    }

    private static boolean isOpenProject(Project p) {
        return OpenProjects.getDefault().isProjectOpen(p);
        for (int i = 0; i < opened.length; i++) {
            if (p.equals(opened[i]) || opened[i].equals(p)) {
                return true;
            }
        }
        return false;
    }
    
    private static Collection<TypeElement> typesToElements(Collection<? extends TypeMirror> types, CompilationInfo info) {

Lines 91-97 Link Here

(-)a/ruby.refactoring/nbproject/project.xml (-1 / +1 lines)
91	<compile-dependency/>	91	<compile-dependency/>
92	<run-dependency>	92	<run-dependency>
93	<release-version>1</release-version>	93	<release-version>1</release-version>
94	<specification-version>1.22</specification-version>	94	<specification-version>1.34</specification-version>
95	</run-dependency>	95	</run-dependency>
96	</dependency>	96	</dependency>
97	<dependency>	97	<dependency>

Lines 270-280 Link Here

(-)a/ruby.refactoring/src/org/netbeans/modules/refactoring/ruby/RetoucheUtils.java (-5 / +2 lines)
270	public static boolean isFileInOpenProject(FileObject file) {	270	public static boolean isFileInOpenProject(FileObject file) {
271	assert file != null;	271	assert file != null;
272	Project p = FileOwnerQuery.getOwner(file);	272	Project p = FileOwnerQuery.getOwner(file);
273	Project[] opened = OpenProjects.getDefault().getOpenProjects();	273	if (OpenProjects.getDefault().isProjectOpen(p)) {
274	for (int i = 0; i<opened.length; i++) {	274	return true;
275	if (p.equals(opened[i]) \|\| opened[i].equals(p)) {
276	return true;
277	}
278	}	275	}
279	return false;	276	return false;
280	}	277	}

Lines 107-113 Link Here

(-)a/web.refactoring/nbproject/project.xml (-10 / +10 lines)
107	<compile-dependency/>	107	<compile-dependency/>
108	<run-dependency>	108	<run-dependency>
109	<release-version>1</release-version>	109	<release-version>1</release-version>
110	<specification-version>1.24</specification-version>	110	<specification-version>1.34</specification-version>
111	</run-dependency>	111	</run-dependency>
112	</dependency>	112	</dependency>
113	<dependency>	113	<dependency>
Lines 134-139 Link Here
134	<run-dependency>	134	<run-dependency>
135	<release-version>1</release-version>	135	<release-version>1</release-version>
136	<specification-version>1.16</specification-version>	136	<specification-version>1.16</specification-version>
		137	</run-dependency>
		138	</dependency>
		139	<dependency>
		140	<code-name-base>org.netbeans.modules.web.core</code-name-base>
		141	<build-prerequisite/>
		142	<compile-dependency/>
		143	<run-dependency>
		144	<release-version>2</release-version>
		145	<implementation-version/>
137	</run-dependency>	146	</run-dependency>
138	</dependency>	147	</dependency>
139	<dependency>	148	<dependency>
Lines 182-196 Link Here
182	<compile-dependency/>	191	<compile-dependency/>
183	<run-dependency>	192	<run-dependency>
184	<specification-version>6.16</specification-version>	193	<specification-version>6.16</specification-version>
185	</run-dependency>
186	</dependency>
187	<dependency>
188	<code-name-base>org.netbeans.modules.web.core</code-name-base>
189	<build-prerequisite/>
190	<compile-dependency/>
191	<run-dependency>
192	<release-version>2</release-version>
193	<implementation-version/>
194	</run-dependency>	194	</run-dependency>
195	</dependency>	195	</dependency>
196	</module-dependencies>	196	</module-dependencies>




import org.netbeans.modules.refactoring.api.AbstractRefactoring;
import org.netbeans.modules.refactoring.api.Problem;
import org.netbeans.modules.refactoring.api.RenameRefactoring;
import org.netbeans.spi.java.classpath.ClassPathProvider;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.util.Exceptions;

    public static boolean isOnSourceClasspath(FileObject fo) {
        Project p = FileOwnerQuery.getOwner(fo);
        if (p==null) return false;
        if (OpenProjects.getDefault().isProjectOpen(p)) {
            SourceGroup[] gr = ProjectUtils.getSources(p).getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
            for (int j = 0; j < gr.length; j++) {
                if (fo==gr[j].getRootFolder()) return true;
                if (FileUtil.isParentOf(gr[j].getRootFolder(), fo))
                    return true;
                    if (FileUtil.isParentOf(gr[j].getRootFolder(), fo))
                        return true;
                }
                return false;
            }
            return false;
        }
        return false;
    }

Return to bug 161120

Lines 201-213 Link Here

(-)a/apisupport.refactoring/src/org/netbeans/modules/apisupport/refactoring/RetoucheUtils.java (-7 / +1 lines)
201	public static boolean isFileInOpenProject(FileObject file) {	201	public static boolean isFileInOpenProject(FileObject file) {
202	assert file != null;	202	assert file != null;
203	Project p = FileOwnerQuery.getOwner(file);	203	Project p = FileOwnerQuery.getOwner(file);
204	Project[] opened = OpenProjects.getDefault().getOpenProjects();	204	return OpenProjects.getDefault().isProjectOpen(p);
205	for (int i = 0; i<opened.length; i++) {
206	if (p.equals(opened[i]) \|\| opened[i].equals(p)) {
207	return true;
208	}
209	}
210	return false;
211	}	205	}
212		206
213	public static boolean isOnSourceClasspath(FileObject fo) {	207	public static boolean isOnSourceClasspath(FileObject fo) {

Lines 247-259 Link Here

(-)a/javascript.refactoring/src/org/netbeans/modules/refactoring/javascript/RetoucheUtils.java (-7 / +1 lines)
247	public static boolean isFileInOpenProject(FileObject file) {	247	public static boolean isFileInOpenProject(FileObject file) {
248	assert file != null;	248	assert file != null;
249	Project p = FileOwnerQuery.getOwner(file);	249	Project p = FileOwnerQuery.getOwner(file);
250	Project[] opened = OpenProjects.getDefault().getOpenProjects();	250	return OpenProjects.getDefault().isProjectOpen(p);
251	for (int i = 0; i<opened.length; i++) {
252	if (p.equals(opened[i]) \|\| opened[i].equals(p)) {
253	return true;
254	}
255	}
256	return false;
257	}	251	}
258		252
259	public static boolean isOnSourceClasspath(FileObject fo) {	253	public static boolean isOnSourceClasspath(FileObject fo) {

Lines 227-239 Link Here

(-)a/php.refactoring/src/org/netbeans/modules/refactoring/php/findusages/RefactoringUtils.java (-7 / +1 lines)
227	public static boolean isFileInOpenProject(FileObject file) {	227	public static boolean isFileInOpenProject(FileObject file) {
228	assert file != null;	228	assert file != null;
229	Project p = FileOwnerQuery.getOwner(file);	229	Project p = FileOwnerQuery.getOwner(file);
230	Project[] opened = OpenProjects.getDefault().getOpenProjects();	230	return OpenProjects.getDefault().isProjectOpen(p);
231	for (int i = 0; i < opened.length; i++) {
232	if (p.equals(opened[i]) \|\| opened[i].equals(p)) {
233	return true;
234	}
235	}
236	return false;
237	}	231	}
238		232
239	public static boolean isOnSourceClasspath(FileObject fo) {	233	public static boolean isOnSourceClasspath(FileObject fo) {

Lines 478-490 Link Here

(-)a/refactoring.java/src/org/netbeans/modules/refactoring/java/RetoucheUtils.java (-7 / +1 lines)
478	}	478	}
479		479
480	private static boolean isOpenProject(Project p) {	480	private static boolean isOpenProject(Project p) {
481	Project[] opened = OpenProjects.getDefault().getOpenProjects();	481	return OpenProjects.getDefault().isProjectOpen(p);
482	for (int i = 0; i < opened.length; i++) {
483	if (p.equals(opened[i]) \|\| opened[i].equals(p)) {
484	return true;
485	}
486	}
487	return false;
488	}	482	}
489		483
490	private static Collection<TypeElement> typesToElements(Collection<? extends TypeMirror> types, CompilationInfo info) {	484	private static Collection<TypeElement> typesToElements(Collection<? extends TypeMirror> types, CompilationInfo info) {

Lines 89-101 Link Here

(-)a/cnd.refactoring/src/org/netbeans/modules/cnd/refactoring/support/CsmRefactoringUtils.java (-7 / +1 lines)
89	return false;	89	return false;
90	}	90	}
91	Project p = FileOwnerQuery.getOwner(f);	91	Project p = FileOwnerQuery.getOwner(f);
92	Project[] opened = OpenProjects.getDefault().getOpenProjects();	92	return OpenProjects.getDefault().isProjectOpen(p);
93	for (int i = 0; i < opened.length; i++) {
94	if (p.equals(opened[i]) \|\| opened[i].equals(p)) {
95	return true;
96	}
97	}
98	return false;
99	}	93	}
100		94
101	public static boolean isRefactorable(FileObject fo) {	95	public static boolean isRefactorable(FileObject fo) {

Lines 20-25 Link Here

(-)a/groovy.refactoring/nbproject/project.xml (-18 / +18 lines)
20	<compile-dependency/>	20	<compile-dependency/>
21	<run-dependency>	21	<run-dependency>
22	<specification-version>0.7</specification-version>	22	<specification-version>0.7</specification-version>
		23	</run-dependency>
		24	</dependency>
		25	<dependency>
		26	<code-name-base>org.netbeans.modules.csl.api</code-name-base>
		27	<build-prerequisite/>
		28	<compile-dependency/>
		29	<run-dependency>
		30	<release-version>0-1</release-version>
		31	<specification-version>1.8</specification-version>
23	</run-dependency>	32	</run-dependency>
24	</dependency>	33	</dependency>
25	<dependency>	34	<dependency>
Lines 49-71 Link Here
49	</run-dependency>	58	</run-dependency>
50	</dependency>	59	</dependency>
51	<dependency>	60	<dependency>
52	<code-name-base>org.netbeans.modules.csl.api</code-name-base>
53	<build-prerequisite/>
54	<compile-dependency/>
55	<run-dependency>
56	<release-version>0-1</release-version>
57	<specification-version>1.8</specification-version>
58	</run-dependency>
59	</dependency>
60	<dependency>
61	<code-name-base>org.netbeans.modules.parsing.api</code-name-base>
62	<build-prerequisite/>
63	<compile-dependency/>
64	<run-dependency>
65	<specification-version>1.0</specification-version>
66	</run-dependency>
67	</dependency>
68	<dependency>
69	<code-name-base>org.netbeans.modules.java.project</code-name-base>	61	<code-name-base>org.netbeans.modules.java.project</code-name-base>
70	<build-prerequisite/>	62	<build-prerequisite/>
71	<compile-dependency/>	63	<compile-dependency/>
Lines 92-97 Link Here
92	</run-dependency>	84	</run-dependency>
93	</dependency>	85	</dependency>
94	<dependency>	86	<dependency>
		87	<code-name-base>org.netbeans.modules.parsing.api</code-name-base>
		88	<build-prerequisite/>
		89	<compile-dependency/>
		90	<run-dependency>
		91	<specification-version>1.0</specification-version>
		92	</run-dependency>
		93	</dependency>
		94	<dependency>
95	<code-name-base>org.netbeans.modules.projectapi</code-name-base>	95	<code-name-base>org.netbeans.modules.projectapi</code-name-base>
96	<build-prerequisite/>	96	<build-prerequisite/>
97	<compile-dependency/>	97	<compile-dependency/>
Lines 106-112 Link Here
106	<compile-dependency/>	106	<compile-dependency/>
107	<run-dependency>	107	<run-dependency>
108	<release-version>1</release-version>	108	<release-version>1</release-version>
109	<specification-version>1.31</specification-version>	109	<specification-version>1.34</specification-version>
110	</run-dependency>	110	</run-dependency>
111	</dependency>	111	</dependency>
112	<dependency>	112	<dependency>

Lines 142-158 Link Here

(-)a/groovy.refactoring/src/org/netbeans/modules/groovy/refactoring/RefactoringUtil.java (-10 / +7 lines)
142	public static boolean isOnSourceClasspath(FileObject fo) {	142	public static boolean isOnSourceClasspath(FileObject fo) {
143	Project p = FileOwnerQuery.getOwner(fo);	143	Project p = FileOwnerQuery.getOwner(fo);
144	if (p==null) return false;	144	if (p==null) return false;
145	Project[] opened = OpenProjects.getDefault().getOpenProjects();	145	if (OpenProjects.getDefault().isProjectOpen(p)) {
146	for (int i = 0; i<opened.length; i++) {	146	SourceGroup[] gr = ProjectUtils.getSources(p).getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
147	if (p.equals(opened[i]) \|\| opened[i].equals(p)) {	147	for (int j = 0; j < gr.length; j++) {
148	SourceGroup[] gr = ProjectUtils.getSources(p).getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);	148	if (fo==gr[j].getRootFolder()) return true;
149	for (int j = 0; j < gr.length; j++) {	149	if (FileUtil.isParentOf(gr[j].getRootFolder(), fo))
150	if (fo==gr[j].getRootFolder()) return true;	150	return true;
151	if (FileUtil.isParentOf(gr[j].getRootFolder(), fo))
152	return true;
153	}
154	return false;
155	}	151	}
		152	return false;
156	}	153	}
157	return false;	154	return false;
158	}	155	}

Lines 81-86 Link Here

(-)a/ide.ergonomics/src/org/netbeans/modules/ide/ergonomics/fod/FeatureProjectFactory.java (-2 / +17 lines)
81	import javax.xml.parsers.ParserConfigurationException;	81	import javax.xml.parsers.ParserConfigurationException;
82	import org.netbeans.api.project.ui.OpenProjects;	82	import org.netbeans.api.project.ui.OpenProjects;
83	import org.openide.filesystems.FileUtil;	83	import org.openide.filesystems.FileUtil;
		84	import org.openide.util.Mutex;
84	import org.xml.sax.SAXException;	85	import org.xml.sax.SAXException;
85		86
86	/**	87	/**
Lines 353-360 Link Here
353	}	354	}
354	if (s != null) {	355	if (s != null) {
355	try {	356	try {
356	s.notifyDeleted();	357	class FindProject implements Mutex.ExceptionAction<Project> {
357	Project p = ProjectManager.getDefault().findProject(getProjectDirectory());	358	ProjectState s;
		359
		360	public Project run() throws IOException {
		361	for (ProjectFactory pf : Lookup.getDefault().lookupAll(ProjectFactory.class)) {
		362	Project p = pf.loadProject(getProjectDirectory(), s);
		363	if (p != null) {
		364	return p;
		365	}
		366	}
		367	return null;
		368	}
		369	}
		370	FindProject findProject = new FindProject();
		371	findProject.s = s;
		372	Project p = ProjectManager.mutex().readAccess(findProject);
358	if (p == FeatureNonProject.this) {	373	if (p == FeatureNonProject.this) {
359	throw new IllegalStateException("New project shall be found! " + p); // NOI18N	374	throw new IllegalStateException("New project shall be found! " + p); // NOI18N
360	}	375	}

Lines 129-145 Link Here

(-)a/j2ee.jpa.refactoring/src/org/netbeans/modules/j2ee/jpa/refactoring/RefactoringUtil.java (-10 / +7 lines)
129	public static boolean isOnSourceClasspath(FileObject fo) {	129	public static boolean isOnSourceClasspath(FileObject fo) {
130	Project p = FileOwnerQuery.getOwner(fo);	130	Project p = FileOwnerQuery.getOwner(fo);
131	if (p==null) return false;	131	if (p==null) return false;
132	Project[] opened = OpenProjects.getDefault().getOpenProjects();	132	if (OpenProjects.getDefault().isProjectOpen(p)) {
133	for (int i = 0; i<opened.length; i++) {	133	SourceGroup[] gr = ProjectUtils.getSources(p).getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
134	if (p.equals(opened[i]) \|\| opened[i].equals(p)) {	134	for (int j = 0; j < gr.length; j++) {
135	SourceGroup[] gr = ProjectUtils.getSources(p).getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);	135	if (fo==gr[j].getRootFolder()) return true;
136	for (int j = 0; j < gr.length; j++) {	136	if (FileUtil.isParentOf(gr[j].getRootFolder(), fo))
137	if (fo==gr[j].getRootFolder()) return true;	137	return true;
138	if (FileUtil.isParentOf(gr[j].getRootFolder(), fo))
139	return true;
140	}
141	return false;
142	}	138	}
		139	return false;
143	}	140	}
144	return false;	141	return false;
145	}	142	}

Lines 104-109 Link Here

(-)a/projectuiapi/apichanges.xml (+17 lines)
104	<!-- ACTUAL CHANGES BEGIN HERE: -->	104	<!-- ACTUAL CHANGES BEGIN HERE: -->
105		105
106	<changes>	106	<changes>
		107	<change id="isProjectOpen">
		108	<api name="general"/>
		109	<summary>Utility method OpenProjects.isProjectOpen</summary>
		110	<version major="1" minor="34"/>
		111	<date day="7" month="4" year="2009"/>
		112	<author login="jtulach"/>
		113	<compatibility addition="yes" binary="compatible" deletion="no" deprecation="no" modification="no" semantic="compatible" source="compatible"/>
		114	<description>
		115	<p>
		116	It came to our attention that often users of <code>OpenProjects</code>
		117	want to find out if their project is opened or not. To simplify
		118	such code we offer a handy utility method.
		119	</p>
		120	</description>
		121	<class package="org.netbeans.api.project.ui" name="OpenProjects"/>
		122	<issue number="161120"/>
		123	</change>
107	<change id="nodefactory-ann">	124	<change id="nodefactory-ann">
108	<api name="general"/>	125	<api name="general"/>
109	<summary>Add annotation @NodeFactory.Registration</summary>	126	<summary>Add annotation @NodeFactory.Registration</summary>

Lines 169-174 Link Here

(-)a/projectuiapi/src/org/netbeans/api/project/ui/OpenProjects.java (+17 lines)
169	trampoline.openAPI (projects,openSubprojects);	169	trampoline.openAPI (projects,openSubprojects);
170	}	170	}
171		171
		172	/** Finds out if the project is opened.
		173	* @param p the project to verify
		174	* @return true if this project is among open ones, false otherwise
		175	* @since 1.34
		176	*/
		177	public boolean isProjectOpen(Project p) {
		178	if (p == null) {
		179	return false;
		180	}
		181	for (Project real : getOpenProjects()) {
		182	if (p.equals(real) \|\| real.equals(p)) {
		183	return true;
		184	}
		185	}
		186	return false;
		187	}
		188
172	/**	189	/**
173	* Closes given projects.	190	* Closes given projects.
174	* Acquires {@link org.netbeans.api.project.ProjectManager#mutex()} in the write mode.	191	* Acquires {@link org.netbeans.api.project.ProjectManager#mutex()} in the write mode.

Lines 55-61 Link Here

(-)a/web.refactoring/src/org/netbeans/modules/web/refactoring/RefactoringUtil.java (-11 / +7 lines)
55	import org.netbeans.modules.refactoring.api.AbstractRefactoring;	55	import org.netbeans.modules.refactoring.api.AbstractRefactoring;
56	import org.netbeans.modules.refactoring.api.Problem;	56	import org.netbeans.modules.refactoring.api.Problem;
57	import org.netbeans.modules.refactoring.api.RenameRefactoring;	57	import org.netbeans.modules.refactoring.api.RenameRefactoring;
58	import org.netbeans.spi.java.classpath.ClassPathProvider;
59	import org.openide.filesystems.FileObject;	58	import org.openide.filesystems.FileObject;
60	import org.openide.filesystems.FileUtil;	59	import org.openide.filesystems.FileUtil;
61	import org.openide.util.Exceptions;	60	import org.openide.util.Exceptions;
Lines 129-145 Link Here
129	public static boolean isOnSourceClasspath(FileObject fo) {	128	public static boolean isOnSourceClasspath(FileObject fo) {
130	Project p = FileOwnerQuery.getOwner(fo);	129	Project p = FileOwnerQuery.getOwner(fo);
131	if (p==null) return false;	130	if (p==null) return false;
132	Project[] opened = OpenProjects.getDefault().getOpenProjects();	131	if (OpenProjects.getDefault().isProjectOpen(p)) {
133	for (int i = 0; i<opened.length; i++) {	132	SourceGroup[] gr = ProjectUtils.getSources(p).getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
134	if (p.equals(opened[i]) \|\| opened[i].equals(p)) {	133	for (int j = 0; j < gr.length; j++) {
135	SourceGroup[] gr = ProjectUtils.getSources(p).getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);	134	if (fo==gr[j].getRootFolder()) return true;
136	for (int j = 0; j < gr.length; j++) {	135	if (FileUtil.isParentOf(gr[j].getRootFolder(), fo))
137	if (fo==gr[j].getRootFolder()) return true;	136	return true;
138	if (FileUtil.isParentOf(gr[j].getRootFolder(), fo))
139	return true;
140	}
141	return false;
142	}	137	}
		138	return false;
143	}	139	}
144	return false;	140	return false;
145	}	141	}