Attachment #109994 for bug #196455

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

Lines 116-121 Link Here

(-)a/j2ee.api.ejbmodule/nbproject/project.xml (+1 lines)
116	<compile-dependency/>	116	<compile-dependency/>
117	<run-dependency>	117	<run-dependency>
118	<release-version>1</release-version>	118	<release-version>1</release-version>
		119	<specification-version>1.10</specification-version>
119	</run-dependency>	120	</run-dependency>
120	</dependency>	121	</dependency>
121	<dependency>	122	<dependency>




package org.netbeans.modules.j2ee.spi.ejbjar.support;

import java.io.IOException;
import java.net.URI;
import java.util.HashSet;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.netbeans.api.j2ee.core.Profile;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectManager;

import org.netbeans.modules.j2ee.dd.api.ejb.EjbJarMetadata;
import org.netbeans.modules.j2ee.metadata.model.api.MetadataModel;
import org.netbeans.modules.j2ee.metadata.model.api.MetadataModelAction;
import org.netbeans.spi.java.project.classpath.ProjectClassPathExtender;
import org.netbeans.spi.project.support.ant.AntProjectHelper;
import org.netbeans.spi.project.support.ant.EditableProperties;
import org.openide.filesystems.FileObject;

            return addReference(ref, refType, ejbRefName, true, referencingFile, referencingClass);
        }
        
        private String addReference(final EjbReference ejbReference, final EjbReference.EjbRefIType refType, final String ejbRefName, final boolean local, final FileObject referencingFile,
                final String referencingClass) throws IOException {

            final org.netbeans.modules.j2ee.api.ejbjar.EjbJar ejbModule = findEjbModule(referencingFile);

                    
                    if(!fromSameProject) {
                        try {
                            ProjectClassPathModifier.addAntArtifacts(new AntArtifact[] {moduleJarTarget}, new URI[] {moduleJarTarget.getArtifactLocations()[0]}, referencingFile, ClassPath.COMPILE);
                            assert pcpe != null;
                            pcpe.addAntArtifact(moduleJarTarget, moduleJarTarget.getArtifactLocations()[0]);
                        } catch (IOException ioe) {
                            Exceptions.printStackTrace(ioe);
                        }

Lines 226-232 Link Here

(-)a/j2ee.clientproject/nbproject/project.xml (-1 / +1 lines)
226	<compile-dependency/>	226	<compile-dependency/>
227	<run-dependency>	227	<run-dependency>
228	<release-version>1</release-version>	228	<release-version>1</release-version>
229	<specification-version>1.37</specification-version>	229	<specification-version>1.41</specification-version>
230	</run-dependency>	230	</run-dependency>
231	</dependency>	231	</dependency>
232	<dependency>	232	<dependency>




import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.net.URL;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.Icon;
import javax.swing.JButton;
import org.netbeans.api.j2ee.core.Profile;
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.java.project.classpath.ProjectClassPathModifier;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectManager;
import org.netbeans.api.project.ProjectUtils;

import org.netbeans.modules.j2ee.clientproject.wsclient.AppClientProjectWebServicesSupportProvider;
import org.netbeans.modules.j2ee.common.SharabilityUtility;
import org.netbeans.modules.j2ee.common.Util;
import org.netbeans.modules.java.api.common.classpath.ClassPathExtender;
import org.netbeans.modules.java.api.common.classpath.ClassPathModifier;
import org.netbeans.modules.java.api.common.classpath.ClassPathSupport;
import org.netbeans.modules.java.api.common.classpath.ClassPathProviderImpl;

import org.netbeans.spi.project.ui.RecommendedTemplates;
import org.netbeans.spi.project.ui.support.UILookupMergerSupport;
import org.netbeans.spi.queries.FileEncodingQueryImplementation;
import org.openide.DialogDisplayer;
import org.openide.NotifyDescriptor;
import org.openide.filesystems.FileAttributeEvent;
import org.openide.filesystems.FileChangeListener;
import org.openide.filesystems.FileEvent;

import org.openide.util.ImageUtilities;
import org.openide.util.Lookup;
import org.openide.util.NbBundle;
import org.openide.util.RequestProcessor;
import org.openide.util.lookup.Lookups;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

    private final Car apiJar;
    private JarContainerImpl enterpriseResourceSupport;
    private FileObject libFolder;
    private final ClassPathExtender classPathExtender;
    private final ClassPathModifier cpMod;
    private final ClassPathProviderImpl cpProvider;
    private ClassPathUiSupport.Callback classPathUiSupportCallback;

        cpMod = new ClassPathModifier(this, this.updateHelper, eval, refHelper,
            new ClassPathSupportCallbackImpl(helper), createClassPathModifierCallback(), 
            getClassPathUiSupportCallback());
        classPathExtender = new ClassPathExtender(cpMod, ProjectProperties.JAVAC_CLASSPATH, ClassPathSupportCallbackImpl.ELEMENT_INCLUDED_LIBRARIES);
        lookup = createLookup(aux, cpProvider);
    }
    

            encodingQuery,
            QuerySupport.createTemplateAttributesProvider(helper, encodingQuery),
            new RecommendedTemplatesImpl(this.updateHelper),
            ProjectClassPathModifier.extenderForModifier(cpMod),
            cpMod,
            libMod,
            buildExtender,

        
        if (fo.getParent ().equals (libFolder)) {
            try {
                cpMod.addRoots(new URL[] {FileUtil.getArchiveRoot(fo.getURL())}, ProjectProperties.JAVAC_CLASSPATH);
            } catch (IOException e) {
                Exceptions.printStackTrace(e);
            }

                if (libFolderName != null && helper.resolveFile (libFolderName).isDirectory ()) {
                    libFolder = helper.resolveFileObject(libFolderName);
                        FileObject children [] = libFolder.getChildren ();
                        List<URL> libs = new LinkedList<URL>();
                        for (int i = 0; i < children.length; i++) {
                            if (FileUtil.isArchiveFile(children[i])) {
                                libs.add(FileUtil.getArchiveRoot(children[i].getURL()));
                            }
                        }
                        cpMod.addRoots(libs.toArray(new URL[libs.size()]), ProjectProperties.JAVAC_CLASSPATH);
                        libs.toArray(libsArray);
                        classPathExtender.addArchiveFiles(ProjectProperties.JAVAC_CLASSPATH, libsArray, ClassPathSupportCallbackImpl.ELEMENT_INCLUDED_LIBRARIES);
                        libFolder.addFileChangeListener (AppClientProject.this);
                }
                






import java.io.IOException;
import java.net.URI;
import java.util.logging.Logger;
import javax.lang.model.element.TypeElement;
import org.netbeans.api.j2ee.core.Profile;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
import org.netbeans.api.java.source.CompilationController;
import org.netbeans.api.java.source.JavaSource;
import org.netbeans.api.project.FileOwnerQuery;

import org.netbeans.modules.j2ee.dd.api.common.MessageDestinationRef;
import org.netbeans.modules.j2ee.dd.api.common.ResourceRef;
import org.netbeans.modules.j2ee.dd.api.common.VersionNotSupportedException;
import org.netbeans.spi.java.project.classpath.ProjectClassPathExtender;
import org.netbeans.spi.project.support.ant.AntProjectHelper;
import org.netbeans.spi.project.support.ant.EditableProperties;
import org.netbeans.spi.project.support.ant.ReferenceHelper;

            getAppClient().addEjbRef(newRef);
        } catch (ClassNotFoundException ex){}
        
        try {
            AntArtifact target = getAntArtifact(ejbReference, refType);
            ProjectClassPathModifier.addAntArtifacts(new AntArtifact[] {target}, new URI[] {target.getArtifactLocations()[0].normalize()}, referencingFile, ClassPath.COMPILE);
        } catch (IOException ioe) {
            Exceptions.printStackTrace(ioe);
            } catch (IOException ioe) {
                Exceptions.printStackTrace(ioe);
            }
        } else {
            Logger.getLogger("global").log(Level.INFO, "WebProjectClassPathExtender not found in the project lookup of project: " + webProject.getProjectDirectory().getPath());    //NOI18N
        }
        
        writeDD(referencingFile, referencingClass);

Lines 263-269 Link Here

(-)a/j2ee.ejbjarproject/nbproject/project.xml (-1 / +1 lines)
263	<compile-dependency/>	263	<compile-dependency/>
264	<run-dependency>	264	<run-dependency>
265	<release-version>1</release-version>	265	<release-version>1</release-version>
266	<specification-version>1.37</specification-version>	266	<specification-version>1.41</specification-version>
267	</run-dependency>	267	</run-dependency>
268	</dependency>	268	</dependency>
269	<dependency>	269	<dependency>




import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

import org.netbeans.modules.j2ee.common.SharabilityUtility;
import org.netbeans.modules.j2ee.common.Util;
import org.netbeans.modules.j2ee.common.project.ArtifactCopyOnSaveSupport;
import org.netbeans.modules.java.api.common.classpath.ClassPathExtender;
import org.netbeans.modules.java.api.common.classpath.ClassPathModifier;
import org.netbeans.modules.java.api.common.classpath.ClassPathSupport;
import org.netbeans.modules.java.api.common.classpath.ClassPathProviderImpl;

import org.netbeans.modules.j2ee.common.project.ui.UserProjectSettings;
import org.netbeans.modules.j2ee.deployment.devmodules.api.InstanceRemovedException;
import org.netbeans.api.j2ee.core.Profile;
import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
import org.netbeans.api.project.ProjectUtils;
import org.netbeans.modules.j2ee.deployment.devmodules.api.J2eeModule.Type;
import org.netbeans.modules.j2ee.deployment.devmodules.spi.ArtifactListener;

    private EjbProjectJAXWSClientSupport jaxWsClientSupport;
    private SourceRoots sourceRoots;
    private SourceRoots testRoots;
    private final ClassPathExtender classPathExtender; 
    private final ClassPathModifier classPathModifier; 
    private PropertyChangeListener j2eePlatformListener;
    private AntBuildExtender buildExtender;

        classPathModifier = new ClassPathModifier(this, this.updateHelper, eval, refHelper,
            new ClassPathSupportCallbackImpl(helper), createClassPathModifierCallback(), 
            getClassPathUiSupportCallback());
        classPathExtender = new ClassPathExtender(classPathModifier, ProjectProperties.JAVAC_CLASSPATH, ClassPathSupportCallbackImpl.ELEMENT_INCLUDED_LIBRARIES);
        lookup = createLookup(aux, cpProvider);
        css = new CopyOnSaveSupport();
        artifactSupport = new ArtifactCopySupport();

                encodingQuery,
                new RecommendedTemplatesImpl(updateHelper),
                refHelper,
                ProjectClassPathModifier.extenderForModifier(classPathModifier),
                classPathModifier,
                new EjbJarProjectOperations(this),
                new EjbJarPersistenceProvider(this, evaluator(), cpProvider),

        
        if (fo.getParent ().equals (libFolder)) {
            try {
                classPathModifier.addRoots(new URL[] {FileUtil.getArchiveRoot(fo.getURL())}, ProjectProperties.JAVAC_CLASSPATH);
            }
            catch (IOException e) {
                Exceptions.printStackTrace(e);

                if (libFolderName != null && helper.resolveFile (libFolderName).isDirectory ()) {
                    libFolder = helper.resolveFileObject(libFolderName);
                        FileObject[] children = libFolder.getChildren ();
                        List<URL> libs = new LinkedList<URL>();
                        for (int i = 0; i < children.length; i++) {
                            if (FileUtil.isArchiveFile(children[i])) {
                                libs.add(FileUtil.getArchiveRoot(children[i].getURL()));
                            }
                        }
                        FileObject[] libsArray = new FileObject[libs.size()];
                        libs.toArray(libsArray);
                        classPathModifier.addRoots(libs.toArray(new URL[libs.size()]), ProjectProperties.JAVAC_CLASSPATH);
                        libFolder.addFileChangeListener (EjbJarProject.this);
                }
                

Lines 159-165 Link Here

(-)a/java.j2seproject/nbproject/project.xml (-1 / +1 lines)
159	<compile-dependency/>	159	<compile-dependency/>
160	<run-dependency>	160	<run-dependency>
161	<release-version>1</release-version>	161	<release-version>1</release-version>
162	<specification-version>1.37</specification-version>	162	<specification-version>1.41</specification-version>
163	</run-dependency>	163	</run-dependency>
164	</dependency>	164	</dependency>
165	<dependency>	165	<dependency>




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.java.project.classpath.ProjectClassPathModifier;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectManager;
import org.netbeans.api.project.SourceGroup;

    private Lookup createLookup(final AuxiliaryConfiguration aux,
            final J2SEActionProvider actionProvider) {
        FileEncodingQueryImplementation encodingQuery = QuerySupport.createFileEncodingQuery(evaluator(), J2SEProjectProperties.SOURCE_ENCODING);
        @SuppressWarnings("deprecation") Object cpe = new org.netbeans.modules.java.api.common.classpath.ClassPathExtender(
            cpMod, ProjectProperties.JAVAC_CLASSPATH, null);
        final Lookup base = Lookups.fixed(
            J2SEProject.this,
            QuerySupport.createProjectInformation(updateHelper, this, J2SE_PROJECT_ICON),

            QuerySupport.createSharabilityQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()),
            new CoSAwareFileBuiltQueryImpl(QuerySupport.createFileBuiltQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()), this),
            new RecommendedTemplatesImpl (this.updateHelper),
            ProjectClassPathModifier.extenderForModifier(cpMod),
            buildExtender,
            cpMod,
            new J2SEProjectOperations(this, actionProvider),




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

    <changes>
        <change id="ProjectClassPathModifier.extenderForModifier">
            <api name="classpath"/>
            <summary>Added <code>ProjectClassPathModifier.extenderForModifier</code></summary>
            <version major="1" minor="41"/>
            <date day="22" month="8" year="2011"/>
            <author login="jglick"/>
            <compatibility addition="yes">
                <p>
                    Any modules still implementing <code>ProjectClassPathExtender</code> should cease to do so.
                </p>
            </compatibility>
            <description>
                <p>
                    Added a bridge from an old SPI to the newer, preferred SPI.
                    Also added <code>LookupMergerSupport.createClassPathModifierMerger</code>.
                </p>
            </description>
            <class package="org.netbeans.api.java.project.classpath" name="ProjectClassPathModifier"/>
            <class package="org.netbeans.spi.java.project.support" name="LookupMergerSupport"/>
            <issue number="196455"/>
        </change>
        <change id="JAVA_ICON">
            <api name="general"/>
            <summary>Added <code>JavaTemplates.JAVA_ICON</code></summary>

Lines 3-9 Link Here

(-)a/java.project/manifest.mf (-1 / +1 lines)
3	OpenIDE-Module-Layer: org/netbeans/modules/java/project/layer.xml	3	OpenIDE-Module-Layer: org/netbeans/modules/java/project/layer.xml
4	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/java/project/Bundle.properties	4	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/java/project/Bundle.properties
5	OpenIDE-Module-Needs: javax.script.ScriptEngine.freemarker	5	OpenIDE-Module-Needs: javax.script.ScriptEngine.freemarker
6	OpenIDE-Module-Specification-Version: 1.40	6	OpenIDE-Module-Specification-Version: 1.41
7	OpenIDE-Module-Recommends: org.netbeans.spi.java.project.runner.JavaRunnerImplementation	7	OpenIDE-Module-Recommends: org.netbeans.spi.java.project.runner.JavaRunnerImplementation
8	AutoUpdate-Show-In-Client: false	8	AutoUpdate-Show-In-Client: false
9		9




import org.netbeans.api.project.libraries.Library;
import org.netbeans.modules.java.project.classpath.ProjectClassPathModifierAccessor;
import org.netbeans.spi.java.project.classpath.ProjectClassPathModifierImplementation;
import org.netbeans.spi.java.project.support.LookupMergerSupport;
import org.netbeans.spi.project.libraries.support.LibrariesSupport;
import org.netbeans.spi.project.support.ant.PropertyUtils;
import org.openide.filesystems.FileObject;


    }

    /**
     * Translates the new SPI into an instance of the old SPI.
     * Useful to place in project lookup so that you need not bother implementing the old SPI.
     * (Since there was not previously a matching API, old clients may directly look for the old SPI
     * interface in a project's lookup.)
     * Corresponding methods are called using the first reported source group (if any) and extensible classpath type (if any).
     * @param pcpmi the new SPI
     * @return a proxy fitting the old SPI
     * @see #extenderForModifier(Project)
     * @since 1.41
     */
    @SuppressWarnings("deprecation") // XXX seems ineffective against return type
    public static org.netbeans.spi.java.project.classpath.ProjectClassPathExtender extenderForModifier(final ProjectClassPathModifierImplementation pcpmi) {
        return new org.netbeans.spi.java.project.classpath.ProjectClassPathExtender() {
            @Override public boolean addLibrary(Library library) throws IOException {
                SourceGroup[] sgs = ProjectClassPathModifierAccessor.INSTANCE.getExtensibleSourceGroups(pcpmi);
                if (sgs.length == 0) {
                    return false;
                }
                String[] types = ProjectClassPathModifierAccessor.INSTANCE.getExtensibleClassPathTypes(pcpmi, sgs[0]);
                if (types.length == 0) {
                    return false;
                }
                try {
                    return ProjectClassPathModifierAccessor.INSTANCE.addLibraries(new Library[] {library}, pcpmi, sgs[0], types[0]);
                } catch (UnsupportedOperationException x) {
                    return false;
                }
            }
            @Override public boolean addArchiveFile(FileObject archiveFile) throws IOException {
                SourceGroup[] sgs = ProjectClassPathModifierAccessor.INSTANCE.getExtensibleSourceGroups(pcpmi);
                if (sgs.length == 0) {
                    return false;
                }
                String[] types = ProjectClassPathModifierAccessor.INSTANCE.getExtensibleClassPathTypes(pcpmi, sgs[0]);
                if (types.length == 0) {
                    return false;
                }
                URL r = archiveFile.getURL();
                if (FileUtil.isArchiveFile(r)) { // ought to always be true, but Javadoc is vague
                    r = FileUtil.getArchiveRoot(r);
                }
                try {
                    return ProjectClassPathModifierAccessor.INSTANCE.addRoots(new URL[] {r}, pcpmi, sgs[0], types[0]);
                } catch (UnsupportedOperationException x) {
                    return false;
                }
            }
            @Override public boolean addAntArtifact(AntArtifact artifact, URI artifactElement) throws IOException {
                SourceGroup[] sgs = ProjectClassPathModifierAccessor.INSTANCE.getExtensibleSourceGroups(pcpmi);
                if (sgs.length == 0) {
                    return false;
                }
                String[] types = ProjectClassPathModifierAccessor.INSTANCE.getExtensibleClassPathTypes(pcpmi, sgs[0]);
                if (types.length == 0) {
                    return false;
                }
                try {
                    return ProjectClassPathModifierAccessor.INSTANCE.addAntArtifacts(new AntArtifact[] {artifact}, new URI[] {artifactElement}, pcpmi, sgs[0], types[0]);
                } catch (UnsupportedOperationException x) {
                    return false;
                }
            }

        };
    }

    /**
     * Similar to {@link #extenderForModifier(ProjectClassPathModifierImplementation)} but permits the new SPI to be created lazily.
     * This is useful if the project is using {@link LookupMergerSupport#createClassPathModifierMerger} and it is thus impossible to get the final SPI instance
     * during construction of the project's lookup.
     * The new SPI is located at runtime on each call; if not present, false is returned from all methods.
     * @param p a project whose lookup may contain a {@link ProjectClassPathModifierImplementation}
     * @return an SPI equivalent
     * @since 1.41
     */
    @SuppressWarnings("deprecation")
    public static org.netbeans.spi.java.project.classpath.ProjectClassPathExtender extenderForModifier(final Project p) {
        return new org.netbeans.spi.java.project.classpath.ProjectClassPathExtender() {
            @Override public boolean addLibrary(Library library) throws IOException {
                ProjectClassPathModifierImplementation pcpmi = p.getLookup().lookup(ProjectClassPathModifierImplementation.class);
                return pcpmi != null ? extenderForModifier(pcpmi).addLibrary(library) : false;
            }
            @Override public boolean addArchiveFile(FileObject archiveFile) throws IOException {
                ProjectClassPathModifierImplementation pcpmi = p.getLookup().lookup(ProjectClassPathModifierImplementation.class);
                return pcpmi != null ? extenderForModifier(pcpmi).addArchiveFile(archiveFile) : false;
            }
            @Override public boolean addAntArtifact(AntArtifact artifact, URI artifactElement) throws IOException {
                ProjectClassPathModifierImplementation pcpmi = p.getLookup().lookup(ProjectClassPathModifierImplementation.class);
                return pcpmi != null ? extenderForModifier(pcpmi).addAntArtifact(artifact, artifactElement) : false;
            }
        };
    }

}




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

package org.netbeans.modules.java.project.classpath;

import java.io.IOException;
import java.net.URI;
import java.net.URL;
import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedHashSet;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.SourceGroup;
import org.netbeans.api.project.ant.AntArtifact;
import org.netbeans.api.project.libraries.Library;
import org.netbeans.spi.java.project.classpath.ProjectClassPathModifierImplementation;
import org.netbeans.spi.project.LookupMerger;
import org.openide.util.Lookup;

public class ClassPathModifierLookupMerger implements LookupMerger<ProjectClassPathModifierImplementation>{
    
    @Override public Class<ProjectClassPathModifierImplementation> getMergeableClass() {
        return ProjectClassPathModifierImplementation.class;
    }

    @Override public ProjectClassPathModifierImplementation merge(Lookup lookup) {
        return new Modifier(lookup);
    }

    private static class Modifier extends ProjectClassPathModifierImplementation {
        
        private final Lookup context;
        
        private Modifier(Lookup context) {
            this.context = context;
        }
    
        @Override protected SourceGroup[] getExtensibleSourceGroups() {
            Collection<SourceGroup> sgs = new LinkedHashSet<SourceGroup>();
            for (ProjectClassPathModifierImplementation impl : context.lookupAll(ProjectClassPathModifierImplementation.class)) {
                sgs.addAll(Arrays.asList(ProjectClassPathModifierAccessor.INSTANCE.getExtensibleSourceGroups(impl)));
            }
            return sgs.toArray(new SourceGroup[sgs.size()]);
        }

        @Override protected String[] getExtensibleClassPathTypes(SourceGroup sourceGroup) {
            Collection<String> types = new LinkedHashSet<String>();
            for (ProjectClassPathModifierImplementation impl : context.lookupAll(ProjectClassPathModifierImplementation.class)) {
                types.addAll(Arrays.asList(ProjectClassPathModifierAccessor.INSTANCE.getExtensibleClassPathTypes(impl, sourceGroup)));
            }
            return types.toArray(new String[types.size()]);
        }
        
        private interface Op {
            boolean run(ProjectClassPathModifierImplementation impl) throws IOException, UnsupportedOperationException;
        }
        
        private boolean run(Op op) throws IOException, UnsupportedOperationException {
            boolean completedNormally = false;
            UnsupportedOperationException uoe = null;
            for (ProjectClassPathModifierImplementation impl : context.lookupAll(ProjectClassPathModifierImplementation.class)) {
                try {
                    if (op.run(impl)) {
                        return true;
                    } else {
                        completedNormally = true;
                    }
                } catch (UnsupportedOperationException x) {
                    uoe = x;
                }
            }
            if (uoe != null && !completedNormally) {
                throw uoe;
            } else {
                return false;
            }
        }
        
        // closures would be handy here...

        @Override protected boolean addLibraries(final Library[] libraries, final SourceGroup sourceGroup, final String type) throws IOException, UnsupportedOperationException {
            return run(new Op() {
                @Override public boolean run(ProjectClassPathModifierImplementation impl) throws IOException, UnsupportedOperationException {
                    return ProjectClassPathModifierAccessor.INSTANCE.addLibraries(libraries, impl, sourceGroup, type);
                }
            });
        }

        @Override protected boolean removeLibraries(final Library[] libraries, final SourceGroup sourceGroup, final String type) throws IOException, UnsupportedOperationException {
            return run(new Op() {
                @Override public boolean run(ProjectClassPathModifierImplementation impl) throws IOException, UnsupportedOperationException {
                    return ProjectClassPathModifierAccessor.INSTANCE.removeLibraries(libraries, impl, sourceGroup, type);
                }
            });
        }

        @Override protected boolean addRoots(final URL[] classPathRoots, final SourceGroup sourceGroup, final String type) throws IOException, UnsupportedOperationException {
            return run(new Op() {
                @Override public boolean run(ProjectClassPathModifierImplementation impl) throws IOException, UnsupportedOperationException {
                    return ProjectClassPathModifierAccessor.INSTANCE.addRoots(classPathRoots, impl, sourceGroup, type);
                }
            });
        }

        @Override protected boolean removeRoots(final URL[] classPathRoots, final SourceGroup sourceGroup, final String type) throws IOException, UnsupportedOperationException {
            return run(new Op() {
                @Override public boolean run(ProjectClassPathModifierImplementation impl) throws IOException, UnsupportedOperationException {
                    return ProjectClassPathModifierAccessor.INSTANCE.removeRoots(classPathRoots, impl, sourceGroup, type);
                }
            });
        }

        @Override protected boolean addRoots(final URI[] classPathRoots, final SourceGroup sourceGroup, final String type) throws IOException, UnsupportedOperationException {
            return run(new Op() {
                @Override public boolean run(ProjectClassPathModifierImplementation impl) throws IOException, UnsupportedOperationException {
                    return ProjectClassPathModifierAccessor.INSTANCE.addRoots(classPathRoots, impl, sourceGroup, type);
                }
            });
        }

        @Override protected boolean removeRoots(final URI[] classPathRoots, final SourceGroup sourceGroup, final String type) throws IOException, UnsupportedOperationException {
            return run(new Op() {
                @Override public boolean run(ProjectClassPathModifierImplementation impl) throws IOException, UnsupportedOperationException {
                    return ProjectClassPathModifierAccessor.INSTANCE.removeRoots(classPathRoots, impl, sourceGroup, type);
                }
            });
        }

        @Override protected boolean addAntArtifacts(final AntArtifact[] artifacts, final URI[] artifactElements, final SourceGroup sourceGroup, final String type) throws IOException, UnsupportedOperationException {
            return run(new Op() {
                @Override public boolean run(ProjectClassPathModifierImplementation impl) throws IOException, UnsupportedOperationException {
                    return ProjectClassPathModifierAccessor.INSTANCE.addAntArtifacts(artifacts, artifactElements, impl, sourceGroup, type);
                }
            });
        }

        @Override protected boolean removeAntArtifacts(final AntArtifact[] artifacts, final URI[] artifactElements, final SourceGroup sourceGroup, final String type) throws IOException, UnsupportedOperationException {
            return run(new Op() {
                @Override public boolean run(ProjectClassPathModifierImplementation impl) throws IOException, UnsupportedOperationException {
                    return ProjectClassPathModifierAccessor.INSTANCE.removeAntArtifacts(artifacts, artifactElements, impl, sourceGroup, type);
                }
            });
        }

        @Override protected boolean addProjects(final Project[] projects, final SourceGroup sourceGroup, final String type) throws IOException, UnsupportedOperationException {
            return run(new Op() {
                @Override public boolean run(ProjectClassPathModifierImplementation impl) throws IOException, UnsupportedOperationException {
                    return ProjectClassPathModifierAccessor.INSTANCE.addProjects(projects, impl, sourceGroup, type);
                }
            });
        }

    }
    
}





import java.io.IOException;
import java.net.URI;
import java.net.URL;
import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
import org.netbeans.api.project.ant.AntArtifact;
import org.netbeans.api.project.libraries.Library;

 * allow clients to extend its compilation classpath
 * by a new classpath element (JAR, folder, dependent project, or library).
 * @since org.netbeans.modules.java.project/1 1.3
 * @deprecated As a caller, use {@link ProjectClassPathModifier} instead.
 *             As an implementor, use {@link ProjectClassPathModifier#extenderForModifier}.
 */
@Deprecated
public interface ProjectClassPathExtender {

     * @param library to be added
     * @return true in case the classpath was changed
     * @exception IOException in case the project metadata cannot be changed
     * @deprecated Please use {@link ProjectClassPathModifier#addLibraries} instead.
     */
    @Deprecated
    boolean addLibrary(Library library) throws IOException;

     * @param archiveFile ZIP/JAR file to be added
     * @return true in case the classpath was changed
     * @exception IOException in case the project metadata cannot be changed
     * @deprecated Please use {@link ProjectClassPathModifier#addRoots(URL[], FileObject, String)} instead.
     */
    @Deprecated
    boolean addArchiveFile(FileObject archiveFile) throws IOException;

     *                        (must be owned by the artifact and be relative to it)
     * @return true in case the classpath was changed
     * @exception IOException in case the project metadata cannot be changed
     * @deprecated Please use {@link ProjectClassPathModifier#addAntArtifacts} instead.
     */
    @Deprecated
    boolean addAntArtifact(AntArtifact artifact, URI artifactElement) throws IOException;




import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.SourceGroup;


/**
 * An SPI for project's classpaths modification.
 * A project can provide subclass of this class in its {@link Project#getLookup lookup} to
 * allow clients to add or remove new classpath elements (JAR, folder, dependent project, or library) to its 
 * classpaths.
 * @since org.netbeans.modules.java.project/1 1.10

     * Adds libraries into the project's classpath if the
     * libraries are not already included.
     * @param libraries to be added
     * @param sourceGroup of type {@link JavaProjectConstants#SOURCES_TYPE_JAVA}
     * identifying the compilation unit to change
     * @param type the type of the classpath the library should be added to,
     * e.g. {@link ClassPath#COMPILE}
     * @return true in case the classpath was changed (at least one library was added to the classpath),
     * the value false is returned when all the libraries are already included on the classpath.
     * @exception IOException in case the project metadata cannot be changed

     * Removes libraries from the project's classpath if the
     * libraries are included on it.
     * @param libraries to be removed
     * @param sourceGroup of type {@link JavaProjectConstants#SOURCES_TYPE_JAVA}
     * identifying the compilation unit to change
     * @param type the type of the classpath the library should be removed from,
     * e.g. {@link ClassPath#COMPILE}
     * @return true in case the classpath was changed, (at least one library was removed from the classpath),
     * the value false is returned when none of the libraries was included on the classpath.
     * @exception IOException in case the project metadata cannot be changed

     * Adds archive files or folders into the project's classpath if the
     * entries are not already there.
     * @param classPathRoots roots to be added, each root has to be either a root of an archive or a folder
     * @param sourceGroup of type {@link JavaProjectConstants#SOURCES_TYPE_JAVA}
     * identifying the compilation unit to change
     * @param type the type of the classpath the root should be added to,
     * e.g. {@link ClassPath#COMPILE}
     * @return true in case the classpath was changed, (at least one classpath root was added to the classpath),
     * the value false is returned when all the classpath roots are already included on the classpath.
     * @exception IOException in case the project metadata cannot be changed

     * {@link #addRoots(URL[], SourceGroup, String)}. It throws UnsupportedOperationException
     * if URIs are not absolute.
     * @param classPathRoots roots to be added, each root has to be either a root of an archive or a folder; URI can be relative
     * @param sourceGroup of type {@link JavaProjectConstants#SOURCES_TYPE_JAVA}
     * identifying the compilation unit to change
     * @param type the type of the classpath the root should be added to,
     * e.g. {@link ClassPath#COMPILE}
     * @return true in case the classpath was changed, (at least one classpath root was added to the classpath),
     * the value false is returned when all the classpath roots are already included on the classpath.
     * @exception IOException in case the project metadata cannot be changed

     * Removes archive files or folders from the project's classpath if the
     * entries are included on it.
     * @param classPathRoots roots to be removed, each root has to be either a root of an archive or a folder
     * @param sourceGroup of type {@link JavaProjectConstants#SOURCES_TYPE_JAVA}
     * identifying the compilation unit to change
     * @param type the type of the classpath the root should be removed from,
     * e.g. {@link ClassPath#COMPILE}
     * @return true in case the classpath was changed, (at least one classpath root was removed from the classpath),
     * the value false is returned when none of the classpath roots was included on the classpath.
     * @exception IOException in case the project metadata cannot be changed

     * {@link #removeRoots(URL[], SourceGroup, String)}. It throws UnsupportedOperationException
     * if URIs are not absolute.
     * @param classPathRoots roots to be removed, each root has to be either a root of an archive or a folder; URI can be relative
     * @param sourceGroup of type {@link JavaProjectConstants#SOURCES_TYPE_JAVA}
     * identifying the compilation unit to change
     * @param type the type of the classpath the root should be removed from,
     * e.g. {@link ClassPath#COMPILE}
     * @return true in case the classpath was changed, (at least one classpath root was removed from the classpath),
     * the value false is returned when none of the classpath roots was included on the classpath.
     * @exception IOException in case the project metadata cannot be changed

     * @param artifactElements the URIs of the build output, the artifactElements has to have the same length
     * as artifacts. 
     * (must be owned by the artifact and be relative to it)
     * @param sourceGroup of type {@link JavaProjectConstants#SOURCES_TYPE_JAVA}
     * identifying the compilation unit to change
     * @param type the type of the classpath the artifact should be added to,
     * e.g. {@link ClassPath#COMPILE}
     * @return true in case the classpath was changed, (at least one artifact was added to the classpath),
     * the value false is returned when all the artifacts are already included on the classpath.
     * @exception IOException in case the project metadata cannot be changed

     * @param artifactElements the URIs of the build output, the artifactElements has to have the same length
     * as artifacts.
     * (must be owned by the artifact and be relative to it)
     * @param sourceGroup of type {@link JavaProjectConstants#SOURCES_TYPE_JAVA}
     * identifying the compilation unit to change
     * @param type the type of the classpath the artifact should be removed from,
     * e.g. {@link ClassPath#COMPILE}
     * @return true in case the classpath was changed, (at least one artifact was removed from the classpath),
     * the value false is returned when none of the artifacts was included on the classpath.
     * @exception IOException in case the project metadata cannot be changed

     * Other project types can override the behaviour.
     * @param projects to be added
     * (must be owned by the artifact and be relative to it)
     * @param sourceGroup of type {@link JavaProjectConstants#SOURCES_TYPE_JAVA}
     * identifying the compilation unit to change
     * @param type the type of the classpath the artifact should be added to,
     * e.g. {@link ClassPath#COMPILE}
     * @return true in case the classpath was changed, (at least one artifact was added to the classpath),
     * the value false is returned when all the artifacts are already included on the classpath.
     * @exception IOException in case the project metadata cannot be changed

     * adding of an artifact to the classpath of the given type.
     * @since org.netbeans.modules.java.project/1 1.24
     */
    protected boolean addProjects(Project[] projects, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException {
        List<AntArtifact> ants = new ArrayList<AntArtifact>();
        List<URI> antUris = new ArrayList<URI>();
        for (Project prj : projects) {

                antUris.add(aa.getArtifactLocations()[0]);
            }
        }
        return addAntArtifacts(ants.toArray(new AntArtifact[0]), antUris.toArray(new URI[0]), sourceGroup, type);
    }

    /**





package org.netbeans.spi.java.project.support;

import java.io.IOException;
import java.net.URL;
import java.util.Arrays;
import java.util.Collection;

import org.netbeans.api.java.queries.JavadocForBinaryQuery;
import org.netbeans.api.java.queries.SourceForBinaryQuery;
import org.netbeans.api.project.ProjectManager;
import org.netbeans.modules.java.project.classpath.ClassPathModifierLookupMerger;
import org.netbeans.spi.java.classpath.ClassPathProvider;
import org.netbeans.spi.java.project.classpath.ProjectClassPathModifierImplementation;
import org.netbeans.spi.java.queries.JavadocForBinaryQueryImplementation;
import org.netbeans.spi.java.queries.SourceForBinaryQueryImplementation;
import org.netbeans.spi.java.queries.SourceForBinaryQueryImplementation2;

    public static LookupMerger<ClassPathProvider> createClassPathProviderMerger(ClassPathProvider defaultProvider) {
        return new ClassPathProviderMerger(defaultProvider);
    }    

    /**
     * Creates a merger of class path modifiers.
     * All supported source groups and classpath types are unified.
     * The first modifier implementation to return true (or throw {@link IOException}) is accepted.
     * False is returned if all of the implementations do so.
     * {@link UnsupportedOperationException} is thrown only if all of the implementations do so.
     * @return a merger
     * @since 1.41
     */
    public static LookupMerger<ProjectClassPathModifierImplementation> createClassPathModifierMerger() {
        return new ClassPathModifierLookupMerger();
    }

    private static class SFBLookupMerger implements LookupMerger<SourceForBinaryQueryImplementation> {

        public Class<SourceForBinaryQueryImplementation> getMergeableClass() {

Lines 3-7 Link Here

(-)a/maven.persistence/manifest.mf (-1 / +1 lines)
3	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/maven/persistence/Bundle.properties	3	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/maven/persistence/Bundle.properties
4	OpenIDE-Module-Public-Packages: -	4	OpenIDE-Module-Public-Packages: -
5	AutoUpdate-Show-In-Client: false	5	AutoUpdate-Show-In-Client: false
6	OpenIDE-Module-Specification-Version: 1.12	6	OpenIDE-Module-Specification-Version: 1.13
7		7

Lines 91-97 Link Here

(-)a/maven.persistence/nbproject/project.xml (-2 / +2 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.18</specification-version>	94	<specification-version>1.41</specification-version>
95	</run-dependency>	95	</run-dependency>
96	</dependency>	96	</dependency>
97	<dependency>	97	<dependency>
Lines 100-106 Link Here
100	<compile-dependency/>	100	<compile-dependency/>
101	<run-dependency>	101	<run-dependency>
102	<release-version>2</release-version>	102	<release-version>2</release-version>
103	<specification-version>2.0</specification-version>	103	<specification-version>2.19</specification-version>
104	</run-dependency>	104	</run-dependency>
105	</dependency>	105	</dependency>
106	<dependency>	106	<dependency>




import org.netbeans.api.project.ant.AntArtifact;
import org.netbeans.api.project.libraries.Library;
import org.netbeans.modules.maven.api.ModelUtils;
import org.netbeans.spi.java.project.classpath.ProjectClassPathExtender;
import org.netbeans.spi.java.project.classpath.ProjectClassPathModifierImplementation;
import org.netbeans.spi.project.ProjectServiceProvider;
import org.openide.filesystems.FileObject;
import org.openide.util.Exceptions;

/**
 *
 * @author mkleint
 */
@ProjectServiceProvider(service=ProjectClassPathModifierImplementation.class,
projectType="org-netbeans-modules-maven")
public class CPExtender extends ProjectClassPathModifierImplementation {
    private static final String SL_15 = "1.5"; //NOI18N
    private Project project;
    /** Creates a new instance of CPExtender */

        return false;
    }

    private boolean addLibrary(Library library) throws IOException {
        if ("toplink".equals(library.getName())) { //NOI18N
            //TODO would be nice if the toplink lib shipping with netbeans be the same binary
            // then we could just copy the pieces to local repo.

                ModelHandle handle = ModelHandleUtils.createModelHandle(project);
                
                // checking source doesn't work anymore, the wizard requires the level to be 1.5 up front.
                // XXX this seems wrong; what if the source level is already 1.6 or higher? (or "5" or "6"?)
                ModelUtils.checkSourceLevel(handle, SL_15);
                ModelHandleUtils.writeModelHandle(handle, project);
                

        }
        return false;
    }

    @Override protected boolean addRoots(URI[] classPathRoots, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException {
        return false;
    }

    @Override protected boolean removeRoots(URI[] classPathRoots, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException {
        return false;
    }

    @Override protected boolean addProjects(Project[] projects, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException {
        return false;
    }
    

Lines 1-6 Link Here

(-)a/maven/manifest.mf (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	OpenIDE-Module: org.netbeans.modules.maven/2	2	OpenIDE-Module: org.netbeans.modules.maven/2
3	OpenIDE-Module-Specification-Version: 2.18	3	OpenIDE-Module-Specification-Version: 2.19
4	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/maven/Bundle.properties	4	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/maven/Bundle.properties
5	OpenIDE-Module-Layer: org/netbeans/modules/maven/layer.xml	5	OpenIDE-Module-Layer: org/netbeans/modules/maven/layer.xml
6	AutoUpdate-Show-In-Client: false	6	AutoUpdate-Show-In-Client: false

Lines 153-159 Link Here

(-)a/maven/nbproject/project.xml (-1 / +1 lines)
153	<compile-dependency/>	153	<compile-dependency/>
154	<run-dependency>	154	<run-dependency>
155	<release-version>1</release-version>	155	<release-version>1</release-version>
156	<specification-version>1.25</specification-version>	156	<specification-version>1.41</specification-version>
157	</run-dependency>	157	</run-dependency>
158	</dependency>	158	</dependency>
159	<dependency>	159	<dependency>




import org.netbeans.api.annotations.common.CheckForNull;
import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectInformation;
import org.netbeans.api.project.ProjectManager;

import org.netbeans.modules.maven.api.PluginPropertyUtils;
import org.netbeans.modules.maven.api.problem.ProblemReport;
import org.netbeans.modules.maven.classpath.CPExtender;
import org.netbeans.modules.maven.classpath.CPExtenderLookupMerger;
import org.netbeans.modules.maven.classpath.CPModifierLookupMerger;
import org.netbeans.modules.maven.classpath.ClassPathProviderImpl;
import org.netbeans.modules.maven.classpath.MavenSourcesImpl;
import org.netbeans.modules.maven.configurations.M2ConfigProvider;

import org.netbeans.modules.maven.queries.MavenSharabilityQueryImpl;
import org.netbeans.modules.maven.queries.MavenSourceLevelImpl;
import org.netbeans.modules.maven.queries.MavenTestForSourceImpl;
import org.netbeans.spi.java.project.support.LookupMergerSupport;
import org.netbeans.spi.project.LookupMerger;
import org.netbeans.spi.project.ProjectState;
import org.netbeans.spi.project.SubprojectProvider;

                    UILookupMergerSupport.createPrivilegedTemplatesMerger(),
                    UILookupMergerSupport.createRecommendedTemplatesMerger(),
                    LookupProviderSupport.createSourcesMerger(),
                    ProjectClassPathModifier.extenderForModifier(this),
                    extender,
                    LookupMergerSupport.createClassPathModifierMerger(),
                    new BackwardCompatibilityWithMevenideChecker(),
                    new DebuggerChecker(),
                    new CosChecker(this),




 * maven dependencies to the way classpath items are added through this api.
 * @author mkleint
 */
public class CPExtender extends ProjectClassPathModifierImplementation {
public class CPExtender extends ProjectClassPathModifierImplementation implements org.netbeans.spi.java.project.classpath.ProjectClassPathExtender {

    private NbMavenProjectImpl project;
    private static final String POM_XML = "pom.xml"; //NOI18N

        this.project = project;
    }
    
    public boolean addLibrary(final Library library) throws IOException {
        final Boolean[] added = new Boolean[1];
        ModelOperation<POMModel> operation = new ModelOperation<POMModel>() {
            public void performOperation(POMModel model) {
                try {
                    added[0] = addRemoveLibrary(library, model, null, true);
                } catch (IOException ex) {
                    Exceptions.printStackTrace(ex);
                    added[0] = Boolean.FALSE;
                }
            }
        };
        FileObject pom = project.getProjectDirectory().getFileObject(POM_XML);//NOI18N
        org.netbeans.modules.maven.model.Utilities.performPOMModelOperations(pom, Collections.singletonList(operation));
        //TODO is the manual reload necessary if pom.xml file is being saved?
//                NbMavenProject.fireMavenProjectReload(project);
        if (added[0]) {
            project.getLookup().lookup(NbMavenProject.class).triggerDependencyDownload();
        }

        return added[0];
    }
    
    public boolean addArchiveFile(FileObject arch) throws IOException {
        final File jar = FileUtil.archiveOrDirForURL(arch.getURL());
        if (jar == null || jar.isDirectory()) {
            throw new IOException("Cannot add folders to Maven projects as dependencies: " + arch); //NOI18N
        }
        final AtomicBoolean added = new AtomicBoolean();
        ModelOperation<POMModel> operation = new ModelOperation<POMModel>() {
            public void performOperation(POMModel model) {
                try {
                    added.compareAndSet(false, addRemoveJAR(jar, model, null, true));
                } catch (IOException ex) {
                    Exceptions.printStackTrace(ex);
                }
            }
        };
        FileObject pom = project.getProjectDirectory().getFileObject(POM_XML);//NOI18N
        org.netbeans.modules.maven.model.Utilities.performPOMModelOperations(pom, Collections.singletonList(operation));
        if (added.get()) {
            project.getLookup().lookup(NbMavenProject.class).triggerDependencyDownload();
        }
        return added.get();
    }

    private boolean addRemoveLibrary(Library library, POMModel model, String scope, boolean add) throws IOException {
        Boolean modified = checkLibraryForPoms(library, model, scope, add);
        if (modified == null) {

        return modified;
    }
        
    public boolean addAntArtifact(AntArtifact arg0, URI arg1) throws IOException {
        throw new IOException("Cannot add Ant based projects as subprojecs to Maven projects."); //NOI18N
    }
    
    public SourceGroup[] getExtensibleSourceGroups() {
        Sources s = this.project.getLookup().lookup(Sources.class);
        assert s != null;




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

package org.netbeans.modules.maven.classpath;

import java.io.IOException;
import java.net.URI;
import java.util.Collection;
import org.netbeans.api.project.ant.AntArtifact;
import org.netbeans.api.project.libraries.Library;
import org.netbeans.spi.java.project.classpath.ProjectClassPathExtender;
import org.netbeans.spi.project.LookupMerger;
import org.openide.filesystems.FileObject;
import org.openide.util.Lookup;

/**
 *
 * @author mkleint
 */
@SuppressWarnings("deprecation")
public class CPExtenderLookupMerger implements LookupMerger<ProjectClassPathExtender> {

    private CPExtender fallback;
    
    /** Creates a new instance of CPExtenderLookupMerger */
    public CPExtenderLookupMerger(CPExtender fallbck) {
        fallback = fallbck;
        assert fallback != null;
    }
    
    public Class<ProjectClassPathExtender> getMergeableClass() {
        return ProjectClassPathExtender.class;
    }

    public synchronized ProjectClassPathExtender merge(Lookup lookup) {
        return new Extender(lookup);
    }

    @SuppressWarnings("deprecation")
    private class Extender implements ProjectClassPathExtender {
        
        private final Lookup context;
        
        private Extender(Lookup context) {
            this.context = context;
        }
    
        public boolean addLibrary(Library arg0) throws IOException {
            Collection<? extends ProjectClassPathExtender> list = context.lookupAll(ProjectClassPathExtender.class);
            for (ProjectClassPathExtender ext : list) {
                boolean added = ext.addLibrary(arg0);
                if (added) {
                    return added;
                }
            }
            return fallback.addLibrary(arg0);
        }

        public boolean addArchiveFile(FileObject arg0) throws IOException {
            Collection<? extends ProjectClassPathExtender> list = context.lookupAll(ProjectClassPathExtender.class);
            for (ProjectClassPathExtender ext : list) {
                boolean added = ext.addArchiveFile(arg0);
                if (added) {
                    return added;
                }
            }
            return fallback.addArchiveFile(arg0);
        }

        public boolean addAntArtifact(AntArtifact arg0, URI arg1) throws IOException {
            Collection<? extends ProjectClassPathExtender> list = context.lookupAll(ProjectClassPathExtender.class);
            for (ProjectClassPathExtender ext : list) {
                boolean added = ext.addAntArtifact(arg0, arg1);
                if (added) {
                    return added;
                }
            }
            return fallback.addAntArtifact(arg0, arg1);
        }

    }
}




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


package org.netbeans.modules.maven.classpath;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URI;
import java.net.URL;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.SourceGroup;
import org.netbeans.api.project.ant.AntArtifact;
import org.netbeans.api.project.libraries.Library;
import org.netbeans.spi.java.project.classpath.ProjectClassPathModifierImplementation;
import org.netbeans.spi.project.LookupMerger;
import org.openide.util.Lookup;

/**
 * TODO: The idea of having a LookupMerger for this class is not 100% semantically correct.
 * The original add/remove methods return values have different meaning than here.
 * if true is returned from impls means everything is done no further processing necessary, 
 * false means not relevant, try another impl or fallback to default.
 * a proper solution would be to create our own api that would reflect this difference.
 * @author mkleint
 */
public class CPModifierLookupMerger implements LookupMerger<ProjectClassPathModifierImplementation>{
    
    private CPExtender fallback;
    
    /** Creates a new instance of CPExtenderLookupMerger */
    public CPModifierLookupMerger(CPExtender fallbck) {
        fallback = fallbck;
        assert fallback != null;
    }
    
    public Class<ProjectClassPathModifierImplementation> getMergeableClass() {
        return ProjectClassPathModifierImplementation.class;
    }

    public synchronized ProjectClassPathModifierImplementation merge(Lookup lookup) {
        return new Extender(lookup);
    }

    private class Extender extends ProjectClassPathModifierImplementation {
        
        private final Lookup context;
        
        private Extender(Lookup context) {
            this.context = context;
        }
    
        private Object retVal(String methodName, ProjectClassPathModifierImplementation impl, 
                              Class<?>[] paramTypes,
                              Object... params) throws IOException {
            try {
                Method meth = impl.getClass().getDeclaredMethod(methodName, paramTypes);
                meth.setAccessible(true);
                return meth.invoke(impl, params);
            } catch (InvocationTargetException x) {
                if (x.getCause() instanceof IOException) {
                    throw (IOException)x.getCause();
                }
                //JDK16 can replace with new IOException(x.getCause());
                IOException ex = new IOException(x.getCause().getMessage());
                ex.initCause(x.getCause());
                throw ex;
            } catch (Exception e) {
                e.printStackTrace();
                throw new AssertionError("Cannot use reflection on " + impl + " method:" + methodName);
            }
        }

        protected SourceGroup[] getExtensibleSourceGroups() {
            Collection<? extends ProjectClassPathModifierImplementation> list = context.lookupAll(ProjectClassPathModifierImplementation.class);
            Collection<SourceGroup> sg = new HashSet<SourceGroup>();
            for (ProjectClassPathModifierImplementation ext : list) {
                try {
                    SourceGroup[] sgs = (SourceGroup[])retVal("getExtensibleSourceGroups", ext, null);//NOI18N
                    sg.addAll(Arrays.asList(sgs));
                } catch (IOException e) {
                    //should not happen at all.
                }
            }
            sg.addAll(Arrays.asList(fallback.getExtensibleSourceGroups()));
            return sg.toArray(new SourceGroup[sg.size()]);
        }

        protected String[] getExtensibleClassPathTypes(SourceGroup arg0) {
            Collection<? extends ProjectClassPathModifierImplementation> list = context.lookupAll(ProjectClassPathModifierImplementation.class);
            Collection<String> retVal = new HashSet<String>();
            for (ProjectClassPathModifierImplementation ext : list) {
                try {
                    String[] ret = (String[])retVal("getExtensibleClassPathTypes", ext, //NOI18N
                            new Class<?>[] {SourceGroup.class}, arg0 );
                    retVal.addAll(Arrays.asList(ret));
                } catch (IOException e) {
                    //should not happen at all.
                }
            }
            retVal.addAll(Arrays.asList(fallback.getExtensibleClassPathTypes(arg0)));
            return retVal.toArray(new String[retVal.size()]);
        }

        protected boolean addLibraries(Library[] arg0, SourceGroup arg1,
                                       String arg2) throws IOException,
                                                           UnsupportedOperationException {
            Collection<? extends ProjectClassPathModifierImplementation> list = context.lookupAll(ProjectClassPathModifierImplementation.class);
            for (ProjectClassPathModifierImplementation ext : list) {
                Boolean ret = (Boolean)retVal("addLibraries", ext, //NOI18N
                        new Class<?>[] { new Library[0].getClass(), SourceGroup.class, String.class}, arg0, arg1, arg2);
                if (ret.booleanValue()) {
                    return ret.booleanValue();
                }
            }
            return fallback.addLibraries(arg0, arg1, arg2);
        }

        protected boolean removeLibraries(Library[] arg0, SourceGroup arg1,
                                          String arg2) throws IOException,
                                                              UnsupportedOperationException {
            Collection<? extends ProjectClassPathModifierImplementation> list = context.lookupAll(ProjectClassPathModifierImplementation.class);
            for (ProjectClassPathModifierImplementation ext : list) {
                Boolean ret = (Boolean)retVal("removeLibraries", ext, //NOI18N
                        new Class<?>[] { new Library[0].getClass(), SourceGroup.class, String.class}, arg0, arg1, arg2);
                if (ret.booleanValue()) {
                    return ret.booleanValue();
                }
            }
            return fallback.removeLibraries(arg0, arg1, arg2);
        }

        protected boolean addRoots(URL[] arg0, SourceGroup arg1, String arg2) throws IOException,
                                                                                     UnsupportedOperationException {
            Collection<? extends ProjectClassPathModifierImplementation> list = context.lookupAll(ProjectClassPathModifierImplementation.class);
            for (ProjectClassPathModifierImplementation ext : list) {
                Boolean ret = (Boolean)retVal("addRoots", ext, //NOI18N
                        new Class<?>[] { new URL[0].getClass(), SourceGroup.class, String.class}, arg0, arg1, arg2);
                if (ret.booleanValue()) {
                    return ret.booleanValue();
                }
            }
            return fallback.addRoots(arg0, arg1, arg2);
        }

        protected boolean removeRoots(URL[] arg0, SourceGroup arg1, String arg2) throws IOException,
                                                                                        UnsupportedOperationException {
            Collection<? extends ProjectClassPathModifierImplementation> list = context.lookupAll(ProjectClassPathModifierImplementation.class);
            for (ProjectClassPathModifierImplementation ext : list) {
                Boolean ret = (Boolean)retVal("removeRoots", ext, //NOI18N
                        new Class<?>[] { new URL[0].getClass(), SourceGroup.class, String.class}, arg0, arg1, arg2);
                if (ret.booleanValue()) {
                    return ret.booleanValue();
                }
            }
            return fallback.removeRoots(arg0, arg1, arg2);
        }

        protected boolean addAntArtifacts(AntArtifact[] arg0, URI[] arg1,
                                          SourceGroup arg2, String arg3) throws IOException,
                                                                                UnsupportedOperationException {
            Collection<? extends ProjectClassPathModifierImplementation> list = context.lookupAll(ProjectClassPathModifierImplementation.class);
            for (ProjectClassPathModifierImplementation ext : list) {
                Boolean ret = (Boolean)retVal("addAntArtifacts", ext, //NOI18N
                        new Class<?>[] { new AntArtifact[0].getClass(), new URI[0].getClass(), SourceGroup.class, String.class}, arg0, arg1, arg2, arg3);
                if (ret.booleanValue()) {
                    return ret.booleanValue();
                }
            }
            return fallback.addAntArtifacts(arg0, arg1, arg2, arg3);
        }

        protected boolean removeAntArtifacts(AntArtifact[] arg0, URI[] arg1,
                                             SourceGroup arg2, String arg3) throws IOException,
                                                                                   UnsupportedOperationException {
            Collection<? extends ProjectClassPathModifierImplementation> list = context.lookupAll(ProjectClassPathModifierImplementation.class);
            for (ProjectClassPathModifierImplementation ext : list) {
                Boolean ret = (Boolean)retVal("addAntArtifacts", ext, //NOI18N
                        new Class<?>[] { new AntArtifact[0].getClass(), new URI[0].getClass(), SourceGroup.class, String.class}, arg0, arg1, arg2, arg3);
                if (ret.booleanValue()) {
                    return ret.booleanValue();
                }
            }
            return fallback.addAntArtifacts(arg0, arg1, arg2, arg3);
        }

        @Override
        protected boolean addProjects(Project[] projects, SourceGroup sg, String classPathType) throws IOException, UnsupportedOperationException {
//            Collection<? extends ProjectClassPathModifierImplementation> list = context.lookupAll(ProjectClassPathModifierImplementation.class);
//            for (ProjectClassPathModifierImplementation ext : list) {
//                Boolean ret = (Boolean)retVal("addProjects", ext, //NOI18N
//                        new Class<?>[] { new Project[0].getClass(), SourceGroup.class, String.class}, projects, sg, classPathType);
//                if (ret.booleanValue()) {
//                    return ret.booleanValue();
//                }
//            }
            //use only the fallback, as that's the man with correct impl. others might have the ant based default method implementation preserved..
            return fallback.addProjects(projects, sg, classPathType);
        }


    }
    
}

Lines 116-121 Link Here

(-)a/projectimport.jbuilder/nbproject/project.xml (+1 lines)
116	<compile-dependency/>	116	<compile-dependency/>
117	<run-dependency>	117	<run-dependency>
118	<release-version>1</release-version>	118	<release-version>1</release-version>
		119	<specification-version>1.10</specification-version>
119	</run-dependency>	120	</run-dependency>
120	</dependency>	121	</dependency>
121	<dependency>	122	<dependency>





import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;

import java.util.List;
import java.util.Map;
import java.util.logging.Logger;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.platform.JavaPlatform;
import org.netbeans.api.java.platform.JavaPlatformManager;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
import org.netbeans.api.progress.ProgressHandle;
import org.netbeans.api.progress.ProgressHandleFactory;
import org.netbeans.api.project.Project;

import org.netbeans.modules.java.j2seproject.J2SEProject;
import org.netbeans.modules.java.j2seproject.J2SEProjectGenerator;
import org.netbeans.modules.java.j2seproject.ui.customizer.J2SEProjectProperties;
import org.netbeans.spi.java.project.classpath.ProjectClassPathExtender;
import org.netbeans.spi.project.support.ant.AntProjectHelper;
import org.netbeans.spi.project.support.ant.EditableProperties;
import org.openide.filesystems.FileObject;

    
    public  void addDependency(final J2SEProject nbProject,
            final J2SEProject nbSubProject) throws IOException {
        ProjectClassPathExtender nbClsPath = (ProjectClassPathExtender)
        nbProject.getLookup().lookup(ProjectClassPathExtender.class);
        
        AntArtifact[] artifact = AntArtifactQuery.findArtifactsByType(nbSubProject,
                JavaProjectConstants.ARTIFACT_TYPE_JAR);
        FileObject[] roots = nbProject.getSourceRoots().getRoots();
        if (roots.length > 0) {
            ProjectClassPathModifier.addAntArtifacts(artifact, new URI[] {artifact[0].getArtifactLocations()[0]}, roots[0], ClassPath.COMPILE);
        }
    }
    
    private WarningContainer/*<String> warnings*/ addSourceRoots(final ProjectModel projectDefinition,

        
        for (Iterator it = projectDefinition.getUserLibraries().iterator(); it.hasNext();) {
            ProjectModel.UserLibrary userLibrary = (ProjectModel.UserLibrary)it.next();
            ProjectClassPathExtender nbClsPath = (ProjectClassPathExtender) nbProject.getLookup().lookup(ProjectClassPathExtender.class);
            assert nbClsPath != null;
            List allLibs = getAllLibraries(null, userLibrary);
            
            for (Iterator itUL = allLibs.iterator(); itUL.hasNext();) {
                ProjectModel.Library lEntry = (ProjectModel.Library)itUL.next();
                try {
                    warnings.addAll(addLibrary(nbProject, lEntry, projectDefinition));
                } catch(IOException iex) {
                    ImportUtils.addWarning(warnings,iex.getLocalizedMessage());
                }

            final J2SEProject nbProject) throws IOException {
        
        WarningContainer warnings = new WarningContainer();
        ProjectClassPathExtender nbClsPath = (ProjectClassPathExtender) nbProject.getLookup().lookup(ProjectClassPathExtender.class);
        assert nbClsPath != null;
        
        for (Iterator it = projectDefinition.getLibraries().iterator(); it.hasNext();) {
            ProjectModel.Library lEntry = (ProjectModel.Library)it.next();
            try {
                warnings.addAll(addLibrary(nbProject, lEntry, projectDefinition));
            } catch(IOException iex) {
                ImportUtils.addWarning(warnings,iex.getLocalizedMessage());
            }

    }
    
    
    private WarningContainer  addLibrary(final J2SEProject nbProject,
            final ProjectModel.Library lEntry, final ProjectModel projectDefinition) throws IOException {
        WarningContainer warnings = new WarningContainer();
        FileObject archiv = FileUtil.toFileObject(lEntry.getArchiv());
        FileObject[] roots = nbProject.getSourceRoots().getRoots();
        if (roots.length == 0 || !ProjectClassPathModifier.addRoots(new URL[] {FileUtil.getArchiveRoot(archiv.getURL())}, roots[0], ClassPath.COMPILE)) {
            addWarning(warnings, "No Java source roots in: " + FileUtil.getFileDisplayName(nbProject.getProjectDirectory())); // XXX I18N
        }
        return warnings;
    }
    




                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.modules.javaee.specs.support</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <release-version>0</release-version>
                        <specification-version>1.0</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.modules.j2eeserver</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>

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

                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.modules.javaee.specs.support</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <release-version>0</release-version>
                        <specification-version>1.0</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.modules.junit</code-name-base>
                    <run-dependency>
                        <release-version>2</release-version>




import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import javax.swing.Icon;
import javax.swing.JButton;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.netbeans.api.java.classpath.ClassPath;

import org.netbeans.api.project.ant.AntBuildExtender;
import org.netbeans.api.queries.FileBuiltQuery.Status;
import org.netbeans.api.j2ee.core.Profile;
import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
import org.netbeans.modules.j2ee.dd.api.ejb.EjbJarMetadata;
import org.netbeans.modules.j2ee.metadata.model.api.MetadataModelAction;
import org.netbeans.modules.java.api.common.Roots;
import org.netbeans.modules.java.api.common.classpath.ClassPathSupport.Item;
import org.netbeans.modules.j2ee.deployment.devmodules.spi.ArtifactListener.Artifact;
import org.netbeans.modules.web.common.spi.ProjectWebRootProvider;
import org.netbeans.modules.web.jsfapi.spi.JsfSupportHandle;

import org.netbeans.modules.j2ee.common.Util;
import org.netbeans.modules.j2ee.common.dd.DDHelper;
import org.netbeans.modules.j2ee.common.project.ArtifactCopyOnSaveSupport;
import org.netbeans.modules.java.api.common.classpath.ClassPathExtender;
import org.netbeans.modules.java.api.common.classpath.ClassPathModifier;
import org.netbeans.modules.java.api.common.classpath.ClassPathModifierSupport;
import org.netbeans.modules.j2ee.deployment.devmodules.api.J2eePlatform;

import org.netbeans.spi.project.support.ant.PropertyProvider;
import org.netbeans.spi.project.support.ant.PropertyUtils;
import org.netbeans.spi.queries.FileEncodingQueryImplementation;
import org.openide.DialogDisplayer;
import org.openide.NotifyDescriptor;
import org.openide.filesystems.FileLock;
import org.openide.filesystems.FileSystem;
import org.openide.filesystems.FileSystem.AtomicAction;

    private final UpdateHelper updateHelper;
    private final UpdateProjectImpl updateProject;
    private final AuxiliaryConfiguration aux;
    private final ClassPathExtender classPathExtender;
    private final ClassPathModifier cpMod;
    private final WebProjectLibrariesModifierImpl libMod;
    private final ClassPathProviderImpl cpProvider;

        cpMod = new ClassPathModifier(this, this.updateHelper, eval, refHelper,
            new ClassPathSupportCallbackImpl(helper), createClassPathModifierCallback(), getClassPathUiSupportCallback());
        libMod = new WebProjectLibrariesModifierImpl(this, this.updateHelper, eval, refHelper);
        classPathExtender = new ClassPathExtender(cpMod, ProjectProperties.JAVAC_CLASSPATH, ClassPathSupportCallbackImpl.TAG_WEB_MODULE_LIBRARIES);
        lookup = createLookup(aux, cpProvider);
        css = new CopyOnSaveSupport();
        artifactSupport = new ArtifactCopySupport();

                getTestSourceRoots(), WebProjectProperties.WEB_DOCBASE_DIR),
            new RecommendedTemplatesImpl(this),
            new CoSAwareFileBuiltQueryImpl(QuerySupport.createFileBuiltQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()), this),
            ProjectClassPathModifier.extenderForModifier(cpMod),
            buildExtender,
            cpMod,
            new WebProjectOperations(this),

Lines 183-188 Link Here

(-)a/web.struts/nbproject/project.xml (+1 lines)
183	<compile-dependency/>	183	<compile-dependency/>
184	<run-dependency>	184	<run-dependency>
185	<release-version>1</release-version>	185	<release-version>1</release-version>
		186	<specification-version>1.10</specification-version>
186	</run-dependency>	187	</run-dependency>
187	</dependency>	188	</dependency>
188	<dependency>	189	<dependency>




import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.SwingUtilities;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
import org.netbeans.api.project.ProjectUtils;
import org.netbeans.api.project.SourceGroup;
import org.netbeans.modules.j2ee.dd.api.common.CreateCapability;


import org.netbeans.modules.web.struts.ui.StrutsConfigurationPanel;

import org.netbeans.spi.java.project.classpath.ProjectClassPathExtender;
import org.openide.DialogDescriptor;
import org.openide.DialogDisplayer;
import org.openide.NotifyDescriptor;

        
        Library lib = LibraryManager.getDefault().getLibrary("struts");                         //NOI18N
        if (lib != null) {
            SourceGroup[] sgs = ProjectUtils.getSources(project).getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
            if (sgs.length > 0) {
                try {
                    ProjectClassPathModifier.addLibraries(new Library[] {lib}, sgs[0].getRootFolder(), ClassPath.COMPILE);
                } catch (IOException ioe) {
                    Exceptions.printStackTrace(ioe);
                }
            } else {
                Logger.getLogger("global").log(Level.INFO,
                        "WebProjectClassPathExtender not found in the project lookup of project: " + project.getProjectDirectory().getPath());    //NOI18N
            }

            try {

Lines 228-233 Link Here

(-)a/websvc.core/nbproject/project.xml (+1 lines)
228	<compile-dependency/>	228	<compile-dependency/>
229	<run-dependency>	229	<run-dependency>
230	<release-version>1</release-version>	230	<release-version>1</release-version>
		231	<specification-version>1.10</specification-version>
231	</run-dependency>	232	</run-dependency>
232	</dependency>	233	</dependency>
233	<dependency>	234	<dependency>




import javax.lang.model.type.TypeKind;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
import org.netbeans.api.java.source.CancellableTask;
import org.netbeans.api.java.source.Comment;
import org.netbeans.api.java.source.GeneratorUtilities;

import org.netbeans.modules.websvc.api.jaxws.wsdlmodel.WsdlService;
import org.netbeans.modules.websvc.core.JaxWsUtils;
import org.netbeans.modules.websvc.jaxws.api.JAXWSSupport;
import org.netbeans.spi.java.project.classpath.ProjectClassPathExtender;
import org.netbeans.spi.project.ui.templates.support.Templates;
import org.openide.DialogDisplayer;
import org.openide.ErrorManager;


        // check if the wsimport class is already present - this means we don't need to add the library
        SourceGroup[] sgs = ProjectUtils.getSources(project).getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
        if (sgs.length > 0) {
        ClassPath classPath = ClassPath.getClassPath(sgs[0].getRootFolder(), ClassPath.COMPILE);
        FileObject wsimportFO = classPath.findResource("com/sun/tools/ws/ant/WsImport.class"); // NOI18N
        if (wsimportFO != null) {
            return;
        }

        ProjectClassPathExtender pce = (ProjectClassPathExtender) project.getLookup().lookup(ProjectClassPathExtender.class);
        Library jaxws21_ext = LibraryManager.getDefault().getLibrary("jaxws21"); //NOI18N
        if (jaxws21_ext != null) {
            try {
                ProjectClassPathModifier.addLibraries(new Library[] {jaxws21_ext}, sgs[0].getRootFolder(), ClassPath.COMPILE);
            } catch (IOException e) {
                throw new Exception("Unable to add JAXWS 21 Library. " + e.getMessage());
            }

                    "ProjectClassPathExtender or library not found");
        }

        if (sgs.length > 0) {
            try {
                FileObject srcRoot = sgs[0].getRootFolder();
                WSUtils.addJaxWsApiEndorsed(project, srcRoot);




import java.util.Set;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
import org.netbeans.api.java.queries.UnitTestForSourceQuery;
import org.netbeans.api.progress.ProgressHandle;
import org.netbeans.api.progress.ProgressHandleFactory;

import org.netbeans.modules.websvc.api.support.ClientCreator;
import org.netbeans.modules.websvc.core.ClientWizardProperties;
import org.netbeans.modules.websvc.core.WsdlRetriever;
import org.netbeans.modules.websvc.core.WsdlRetriever;
import org.netbeans.spi.java.project.classpath.ProjectClassPathExtender;
import org.openide.DialogDisplayer;
import org.openide.ErrorManager;
import org.openide.NotifyDescriptor;

        FileObject wscompileFO = classPath.findResource("com/sun/xml/rpc/tools/ant/Wscompile.class");
        if (wscompileFO==null) {
            // add jax-rpc16 if webservice is not on classpath
            ProjectClassPathExtender pce = (ProjectClassPathExtender)project.getLookup().lookup(ProjectClassPathExtender.class);
            Library jaxrpclib = LibraryManager.getDefault().getLibrary("jaxrpc16"); //NOI18N
            if (jaxrpclib != null) {
                ProjectClassPathModifier.addLibraries(new Library[] {jaxrpclib}, sgs[0].getRootFolder(), ClassPath.COMPILE);
            }
        }
        

Return to bug 196455

Lines 56-61 Link Here

(-)a/java.project/src/org/netbeans/api/java/project/classpath/ProjectClassPathModifier.java (+95 lines)
56	import org.netbeans.api.project.libraries.Library;	56	import org.netbeans.api.project.libraries.Library;
57	import org.netbeans.modules.java.project.classpath.ProjectClassPathModifierAccessor;	57	import org.netbeans.modules.java.project.classpath.ProjectClassPathModifierAccessor;
58	import org.netbeans.spi.java.project.classpath.ProjectClassPathModifierImplementation;	58	import org.netbeans.spi.java.project.classpath.ProjectClassPathModifierImplementation;
		59	import org.netbeans.spi.java.project.support.LookupMergerSupport;
59	import org.netbeans.spi.project.libraries.support.LibrariesSupport;	60	import org.netbeans.spi.project.libraries.support.LibrariesSupport;
60	import org.netbeans.spi.project.support.ant.PropertyUtils;	61	import org.netbeans.spi.project.support.ant.PropertyUtils;
61	import org.openide.filesystems.FileObject;	62	import org.openide.filesystems.FileObject;
Lines 455-458 Link Here
455		456
456	}	457	}
457		458
		459	/**
		460	* Translates the new SPI into an instance of the old SPI.
		461	* Useful to place in project lookup so that you need not bother implementing the old SPI.
		462	* (Since there was not previously a matching API, old clients may directly look for the old SPI
		463	* interface in a project's lookup.)
		464	* Corresponding methods are called using the first reported source group (if any) and extensible classpath type (if any).
		465	* @param pcpmi the new SPI
		466	* @return a proxy fitting the old SPI
		467	* @see #extenderForModifier(Project)
		468	* @since 1.41
		469	*/
		470	@SuppressWarnings("deprecation") // XXX seems ineffective against return type
		471	public static org.netbeans.spi.java.project.classpath.ProjectClassPathExtender extenderForModifier(final ProjectClassPathModifierImplementation pcpmi) {
		472	return new org.netbeans.spi.java.project.classpath.ProjectClassPathExtender() {
		473	@Override public boolean addLibrary(Library library) throws IOException {
		474	SourceGroup[] sgs = ProjectClassPathModifierAccessor.INSTANCE.getExtensibleSourceGroups(pcpmi);
		475	if (sgs.length == 0) {
		476	return false;
		477	}
		478	String[] types = ProjectClassPathModifierAccessor.INSTANCE.getExtensibleClassPathTypes(pcpmi, sgs[0]);
		479	if (types.length == 0) {
		480	return false;
		481	}
		482	try {
		483	return ProjectClassPathModifierAccessor.INSTANCE.addLibraries(new Library[] {library}, pcpmi, sgs[0], types[0]);
		484	} catch (UnsupportedOperationException x) {
		485	return false;
		486	}
		487	}
		488	@Override public boolean addArchiveFile(FileObject archiveFile) throws IOException {
		489	SourceGroup[] sgs = ProjectClassPathModifierAccessor.INSTANCE.getExtensibleSourceGroups(pcpmi);
		490	if (sgs.length == 0) {
		491	return false;
		492	}
		493	String[] types = ProjectClassPathModifierAccessor.INSTANCE.getExtensibleClassPathTypes(pcpmi, sgs[0]);
		494	if (types.length == 0) {
		495	return false;
		496	}
		497	URL r = archiveFile.getURL();
		498	if (FileUtil.isArchiveFile(r)) { // ought to always be true, but Javadoc is vague
		499	r = FileUtil.getArchiveRoot(r);
		500	}
		501	try {
		502	return ProjectClassPathModifierAccessor.INSTANCE.addRoots(new URL[] {r}, pcpmi, sgs[0], types[0]);
		503	} catch (UnsupportedOperationException x) {
		504	return false;
		505	}
		506	}
		507	@Override public boolean addAntArtifact(AntArtifact artifact, URI artifactElement) throws IOException {
		508	SourceGroup[] sgs = ProjectClassPathModifierAccessor.INSTANCE.getExtensibleSourceGroups(pcpmi);
		509	if (sgs.length == 0) {
		510	return false;
		511	}
		512	String[] types = ProjectClassPathModifierAccessor.INSTANCE.getExtensibleClassPathTypes(pcpmi, sgs[0]);
		513	if (types.length == 0) {
		514	return false;
		515	}
		516	try {
		517	return ProjectClassPathModifierAccessor.INSTANCE.addAntArtifacts(new AntArtifact[] {artifact}, new URI[] {artifactElement}, pcpmi, sgs[0], types[0]);
		518	} catch (UnsupportedOperationException x) {
		519	return false;
		520	}
		521	}
		522
523	};
524	}
525
526	/**
527	* Similar to {@link #extenderForModifier(ProjectClassPathModifierImplementation)} but permits the new SPI to be created lazily.
528	* This is useful if the project is using {@link LookupMergerSupport#createClassPathModifierMerger} and it is thus impossible to get the final SPI instance
529	* during construction of the project's lookup.
530	* The new SPI is located at runtime on each call; if not present, false is returned from all methods.
531	* @param p a project whose lookup may contain a {@link ProjectClassPathModifierImplementation}
532	* @return an SPI equivalent
533	* @since 1.41
534	*/
535	@SuppressWarnings("deprecation")
536	public static org.netbeans.spi.java.project.classpath.ProjectClassPathExtender extenderForModifier(final Project p) {
537	return new org.netbeans.spi.java.project.classpath.ProjectClassPathExtender() {
538	@Override public boolean addLibrary(Library library) throws IOException {
539	ProjectClassPathModifierImplementation pcpmi = p.getLookup().lookup(ProjectClassPathModifierImplementation.class);
540	return pcpmi != null ? extenderForModifier(pcpmi).addLibrary(library) : false;
541	}
542	@Override public boolean addArchiveFile(FileObject archiveFile) throws IOException {
543	ProjectClassPathModifierImplementation pcpmi = p.getLookup().lookup(ProjectClassPathModifierImplementation.class);
544	return pcpmi != null ? extenderForModifier(pcpmi).addArchiveFile(archiveFile) : false;
545	}
546	@Override public boolean addAntArtifact(AntArtifact artifact, URI artifactElement) throws IOException {
547	ProjectClassPathModifierImplementation pcpmi = p.getLookup().lookup(ProjectClassPathModifierImplementation.class);
548	return pcpmi != null ? extenderForModifier(pcpmi).addAntArtifact(artifact, artifactElement) : false;
549	}
550	};
551	}
552
458	}	553	}

Lines 46-51 Link Here

(-)a/projectimport.jbuilder/src/org/netbeans/modules/projectimport/j2seimport/ImportUtils.java (-16 / +14 lines)
46		46
47	import java.io.File;	47	import java.io.File;
48	import java.io.IOException;	48	import java.io.IOException;
		49	import java.net.URI;
49	import java.net.URL;	50	import java.net.URL;
50	import java.util.ArrayList;	51	import java.util.ArrayList;
51	import java.util.Collection;	52	import java.util.Collection;
Lines 54-62 Link Here
54	import java.util.List;	55	import java.util.List;
55	import java.util.Map;	56	import java.util.Map;
56	import java.util.logging.Logger;	57	import java.util.logging.Logger;
		58	import org.netbeans.api.java.classpath.ClassPath;
57	import org.netbeans.api.java.platform.JavaPlatform;	59	import org.netbeans.api.java.platform.JavaPlatform;
58	import org.netbeans.api.java.platform.JavaPlatformManager;	60	import org.netbeans.api.java.platform.JavaPlatformManager;
59	import org.netbeans.api.java.project.JavaProjectConstants;	61	import org.netbeans.api.java.project.JavaProjectConstants;
		62	import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
60	import org.netbeans.api.progress.ProgressHandle;	63	import org.netbeans.api.progress.ProgressHandle;
61	import org.netbeans.api.progress.ProgressHandleFactory;	64	import org.netbeans.api.progress.ProgressHandleFactory;
62	import org.netbeans.api.project.Project;	65	import org.netbeans.api.project.Project;
Lines 68-74 Link Here
68	import org.netbeans.modules.java.j2seproject.J2SEProject;	71	import org.netbeans.modules.java.j2seproject.J2SEProject;
69	import org.netbeans.modules.java.j2seproject.J2SEProjectGenerator;	72	import org.netbeans.modules.java.j2seproject.J2SEProjectGenerator;
70	import org.netbeans.modules.java.j2seproject.ui.customizer.J2SEProjectProperties;	73	import org.netbeans.modules.java.j2seproject.ui.customizer.J2SEProjectProperties;
71	import org.netbeans.spi.java.project.classpath.ProjectClassPathExtender;
72	import org.netbeans.spi.project.support.ant.AntProjectHelper;	74	import org.netbeans.spi.project.support.ant.AntProjectHelper;
73	import org.netbeans.spi.project.support.ant.EditableProperties;	75	import org.netbeans.spi.project.support.ant.EditableProperties;
74	import org.openide.filesystems.FileObject;	76	import org.openide.filesystems.FileObject;
Lines 317-329 Link Here
317		319
318	public void addDependency(final J2SEProject nbProject,	320	public void addDependency(final J2SEProject nbProject,
319	final J2SEProject nbSubProject) throws IOException {	321	final J2SEProject nbSubProject) throws IOException {
320	ProjectClassPathExtender nbClsPath = (ProjectClassPathExtender)
321	nbProject.getLookup().lookup(ProjectClassPathExtender.class);
322
323	AntArtifact[] artifact = AntArtifactQuery.findArtifactsByType(nbSubProject,	322	AntArtifact[] artifact = AntArtifactQuery.findArtifactsByType(nbSubProject,
324	JavaProjectConstants.ARTIFACT_TYPE_JAR);	323	JavaProjectConstants.ARTIFACT_TYPE_JAR);
325		324	FileObject[] roots = nbProject.getSourceRoots().getRoots();
326	nbClsPath.addAntArtifact(artifact[0], artifact[0].getArtifactLocations()[0]);	325	if (roots.length > 0) {
		326	ProjectClassPathModifier.addAntArtifacts(artifact, new URI[] {artifact[0].getArtifactLocations()[0]}, roots[0], ClassPath.COMPILE);
		327	}
327	}	328	}
328		329
329	private WarningContainer/<String> warnings/ addSourceRoots(final ProjectModel projectDefinition,	330	private WarningContainer/<String> warnings/ addSourceRoots(final ProjectModel projectDefinition,
Lines 361-374 Link Here
361		362
362	for (Iterator it = projectDefinition.getUserLibraries().iterator(); it.hasNext();) {	363	for (Iterator it = projectDefinition.getUserLibraries().iterator(); it.hasNext();) {
363	ProjectModel.UserLibrary userLibrary = (ProjectModel.UserLibrary)it.next();	364	ProjectModel.UserLibrary userLibrary = (ProjectModel.UserLibrary)it.next();
364	ProjectClassPathExtender nbClsPath = (ProjectClassPathExtender) nbProject.getLookup().lookup(ProjectClassPathExtender.class);
365	assert nbClsPath != null;
366	List allLibs = getAllLibraries(null, userLibrary);	365	List allLibs = getAllLibraries(null, userLibrary);
367		366
368	for (Iterator itUL = allLibs.iterator(); itUL.hasNext();) {	367	for (Iterator itUL = allLibs.iterator(); itUL.hasNext();) {
369	ProjectModel.Library lEntry = (ProjectModel.Library)itUL.next();	368	ProjectModel.Library lEntry = (ProjectModel.Library)itUL.next();
370	try {	369	try {
371	warnings.addAll(addLibrary(nbClsPath, lEntry, projectDefinition));	370	warnings.addAll(addLibrary(nbProject, lEntry, projectDefinition));
372	} catch(IOException iex) {	371	} catch(IOException iex) {
373	ImportUtils.addWarning(warnings,iex.getLocalizedMessage());	372	ImportUtils.addWarning(warnings,iex.getLocalizedMessage());
374	}	373	}
Lines 394-406 Link Here
394	final J2SEProject nbProject) throws IOException {	393	final J2SEProject nbProject) throws IOException {
395		394
396	WarningContainer warnings = new WarningContainer();	395	WarningContainer warnings = new WarningContainer();
397	ProjectClassPathExtender nbClsPath = (ProjectClassPathExtender) nbProject.getLookup().lookup(ProjectClassPathExtender.class);
398	assert nbClsPath != null;
399
400	for (Iterator it = projectDefinition.getLibraries().iterator(); it.hasNext();) {	396	for (Iterator it = projectDefinition.getLibraries().iterator(); it.hasNext();) {
401	ProjectModel.Library lEntry = (ProjectModel.Library)it.next();	397	ProjectModel.Library lEntry = (ProjectModel.Library)it.next();
402	try {	398	try {
403	warnings.addAll(addLibrary(nbClsPath, lEntry, projectDefinition));	399	warnings.addAll(addLibrary(nbProject, lEntry, projectDefinition));
404	} catch(IOException iex) {	400	} catch(IOException iex) {
405	ImportUtils.addWarning(warnings,iex.getLocalizedMessage());	401	ImportUtils.addWarning(warnings,iex.getLocalizedMessage());
406	}	402	}
Lines 410-421 Link Here
410	}	406	}
411		407
412		408
413	private WarningContainer addLibrary(final ProjectClassPathExtender nbClsPath,	409	private WarningContainer addLibrary(final J2SEProject nbProject,
414	final ProjectModel.Library lEntry, final ProjectModel projectDefinition) throws IOException {	410	final ProjectModel.Library lEntry, final ProjectModel projectDefinition) throws IOException {
415	WarningContainer warnings = new WarningContainer();	411	WarningContainer warnings = new WarningContainer();
416	FileObject archiv = FileUtil.toFileObject(lEntry.getArchiv());	412	FileObject archiv = FileUtil.toFileObject(lEntry.getArchiv());
417		413	FileObject[] roots = nbProject.getSourceRoots().getRoots();
418	nbClsPath.addArchiveFile(archiv);	414	if (roots.length == 0 \|\| !ProjectClassPathModifier.addRoots(new URL[] {FileUtil.getArchiveRoot(archiv.getURL())}, roots[0], ClassPath.COMPILE)) {
		415	addWarning(warnings, "No Java source roots in: " + FileUtil.getFileDisplayName(nbProject.getProjectDirectory())); // XXX I18N
		416	}
419	return warnings;	417	return warnings;
420	}	418	}
421		419

Lines 45-56 Link Here

(-)a/j2ee.api.ejbmodule/src/org/netbeans/modules/j2ee/spi/ejbjar/support/EjbEnterpriseReferenceContainerSupport.java (-5 / +5 lines)
45	package org.netbeans.modules.j2ee.spi.ejbjar.support;	45	package org.netbeans.modules.j2ee.spi.ejbjar.support;
46		46
47	import java.io.IOException;	47	import java.io.IOException;
		48	import java.net.URI;
48	import java.util.HashSet;	49	import java.util.HashSet;
49	import java.util.Set;	50	import java.util.Set;
50	import java.util.logging.Level;	51	import java.util.logging.Level;
51	import java.util.logging.Logger;	52	import java.util.logging.Logger;
52	import org.netbeans.api.j2ee.core.Profile;	53	import org.netbeans.api.j2ee.core.Profile;
		54	import org.netbeans.api.java.classpath.ClassPath;
53	import org.netbeans.api.java.project.JavaProjectConstants;	55	import org.netbeans.api.java.project.JavaProjectConstants;
		56	import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
54	import org.netbeans.api.project.FileOwnerQuery;	57	import org.netbeans.api.project.FileOwnerQuery;
55	import org.netbeans.api.project.Project;	58	import org.netbeans.api.project.Project;
56	import org.netbeans.api.project.ProjectManager;	59	import org.netbeans.api.project.ProjectManager;
Lines 71-77 Link Here
71	import org.netbeans.modules.j2ee.dd.api.ejb.EjbJarMetadata;	74	import org.netbeans.modules.j2ee.dd.api.ejb.EjbJarMetadata;
72	import org.netbeans.modules.j2ee.metadata.model.api.MetadataModel;	75	import org.netbeans.modules.j2ee.metadata.model.api.MetadataModel;
73	import org.netbeans.modules.j2ee.metadata.model.api.MetadataModelAction;	76	import org.netbeans.modules.j2ee.metadata.model.api.MetadataModelAction;
74	import org.netbeans.spi.java.project.classpath.ProjectClassPathExtender;
75	import org.netbeans.spi.project.support.ant.AntProjectHelper;	77	import org.netbeans.spi.project.support.ant.AntProjectHelper;
76	import org.netbeans.spi.project.support.ant.EditableProperties;	78	import org.netbeans.spi.project.support.ant.EditableProperties;
77	import org.openide.filesystems.FileObject;	79	import org.openide.filesystems.FileObject;
Lines 113-119 Link Here
113	return addReference(ref, refType, ejbRefName, true, referencingFile, referencingClass);	115	return addReference(ref, refType, ejbRefName, true, referencingFile, referencingClass);
114	}	116	}
115		117
116	private String addReference(final EjbReference ejbReference, final EjbReference.EjbRefIType refType, final String ejbRefName, final boolean local, FileObject referencingFile,	118	private String addReference(final EjbReference ejbReference, final EjbReference.EjbRefIType refType, final String ejbRefName, final boolean local, final FileObject referencingFile,
117	final String referencingClass) throws IOException {	119	final String referencingClass) throws IOException {
118		120
119	final org.netbeans.modules.j2ee.api.ejbjar.EjbJar ejbModule = findEjbModule(referencingFile);	121	final org.netbeans.modules.j2ee.api.ejbjar.EjbJar ejbModule = findEjbModule(referencingFile);
Lines 181-189 Link Here
181		183
182	if(!fromSameProject) {	184	if(!fromSameProject) {
183	try {	185	try {
184	ProjectClassPathExtender pcpe = ejbProject.getLookup().lookup(ProjectClassPathExtender.class);	186	ProjectClassPathModifier.addAntArtifacts(new AntArtifact[] {moduleJarTarget}, new URI[] {moduleJarTarget.getArtifactLocations()[0]}, referencingFile, ClassPath.COMPILE);
185	assert pcpe != null;
186	pcpe.addAntArtifact(moduleJarTarget, moduleJarTarget.getArtifactLocations()[0]);
187	} catch (IOException ioe) {	187	} catch (IOException ioe) {
188	Exceptions.printStackTrace(ioe);	188	Exceptions.printStackTrace(ioe);
189	}	189	}

Lines 49-54 Link Here

(-)a/j2ee.clientproject/src/org/netbeans/modules/j2ee/clientproject/AppClientProject.java (-14 / +7 lines)
49	import java.io.File;	49	import java.io.File;
50	import java.io.IOException;	50	import java.io.IOException;
51	import java.net.URI;	51	import java.net.URI;
		52	import java.net.URL;
52	import java.util.Arrays;	53	import java.util.Arrays;
53	import java.util.LinkedList;	54	import java.util.LinkedList;
54	import java.util.List;	55	import java.util.List;
Lines 56-66 Link Here
56	import java.util.logging.Level;	57	import java.util.logging.Level;
57	import java.util.logging.Logger;	58	import java.util.logging.Logger;
58	import javax.swing.Icon;	59	import javax.swing.Icon;
59	import javax.swing.JButton;
60	import org.netbeans.api.j2ee.core.Profile;	60	import org.netbeans.api.j2ee.core.Profile;
61	import org.netbeans.api.java.classpath.ClassPath;	61	import org.netbeans.api.java.classpath.ClassPath;
62	import org.netbeans.api.java.classpath.GlobalPathRegistry;	62	import org.netbeans.api.java.classpath.GlobalPathRegistry;
63	import org.netbeans.api.java.project.JavaProjectConstants;	63	import org.netbeans.api.java.project.JavaProjectConstants;
		64	import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
64	import org.netbeans.api.project.Project;	65	import org.netbeans.api.project.Project;
65	import org.netbeans.api.project.ProjectManager;	66	import org.netbeans.api.project.ProjectManager;
66	import org.netbeans.api.project.ProjectUtils;	67	import org.netbeans.api.project.ProjectUtils;
Lines 77-83 Link Here
77	import org.netbeans.modules.j2ee.clientproject.wsclient.AppClientProjectWebServicesSupportProvider;	78	import org.netbeans.modules.j2ee.clientproject.wsclient.AppClientProjectWebServicesSupportProvider;
78	import org.netbeans.modules.j2ee.common.SharabilityUtility;	79	import org.netbeans.modules.j2ee.common.SharabilityUtility;
79	import org.netbeans.modules.j2ee.common.Util;	80	import org.netbeans.modules.j2ee.common.Util;
80	import org.netbeans.modules.java.api.common.classpath.ClassPathExtender;
81	import org.netbeans.modules.java.api.common.classpath.ClassPathModifier;	81	import org.netbeans.modules.java.api.common.classpath.ClassPathModifier;
82	import org.netbeans.modules.java.api.common.classpath.ClassPathSupport;	82	import org.netbeans.modules.java.api.common.classpath.ClassPathSupport;
83	import org.netbeans.modules.java.api.common.classpath.ClassPathProviderImpl;	83	import org.netbeans.modules.java.api.common.classpath.ClassPathProviderImpl;
Lines 122-129 Link Here
122	import org.netbeans.spi.project.ui.RecommendedTemplates;	122	import org.netbeans.spi.project.ui.RecommendedTemplates;
123	import org.netbeans.spi.project.ui.support.UILookupMergerSupport;	123	import org.netbeans.spi.project.ui.support.UILookupMergerSupport;
124	import org.netbeans.spi.queries.FileEncodingQueryImplementation;	124	import org.netbeans.spi.queries.FileEncodingQueryImplementation;
125	import org.openide.DialogDisplayer;
126	import org.openide.NotifyDescriptor;
127	import org.openide.filesystems.FileAttributeEvent;	125	import org.openide.filesystems.FileAttributeEvent;
128	import org.openide.filesystems.FileChangeListener;	126	import org.openide.filesystems.FileChangeListener;
129	import org.openide.filesystems.FileEvent;	127	import org.openide.filesystems.FileEvent;
Lines 137-143 Link Here
137	import org.openide.util.ImageUtilities;	135	import org.openide.util.ImageUtilities;
138	import org.openide.util.Lookup;	136	import org.openide.util.Lookup;
139	import org.openide.util.NbBundle;	137	import org.openide.util.NbBundle;
140	import org.openide.util.RequestProcessor;
141	import org.openide.util.lookup.Lookups;	138	import org.openide.util.lookup.Lookups;
142	import org.w3c.dom.Element;	139	import org.w3c.dom.Element;
143	import org.w3c.dom.NodeList;	140	import org.w3c.dom.NodeList;
Lines 178-184 Link Here
178	private final Car apiJar;	175	private final Car apiJar;
179	private JarContainerImpl enterpriseResourceSupport;	176	private JarContainerImpl enterpriseResourceSupport;
180	private FileObject libFolder;	177	private FileObject libFolder;
181	private final ClassPathExtender classPathExtender;
182	private final ClassPathModifier cpMod;	178	private final ClassPathModifier cpMod;
183	private final ClassPathProviderImpl cpProvider;	179	private final ClassPathProviderImpl cpProvider;
184	private ClassPathUiSupport.Callback classPathUiSupportCallback;	180	private ClassPathUiSupport.Callback classPathUiSupportCallback;
Lines 224-230 Link Here
224	cpMod = new ClassPathModifier(this, this.updateHelper, eval, refHelper,	220	cpMod = new ClassPathModifier(this, this.updateHelper, eval, refHelper,
225	new ClassPathSupportCallbackImpl(helper), createClassPathModifierCallback(),	221	new ClassPathSupportCallbackImpl(helper), createClassPathModifierCallback(),
226	getClassPathUiSupportCallback());	222	getClassPathUiSupportCallback());
227	classPathExtender = new ClassPathExtender(cpMod, ProjectProperties.JAVAC_CLASSPATH, ClassPathSupportCallbackImpl.ELEMENT_INCLUDED_LIBRARIES);
228	lookup = createLookup(aux, cpProvider);	223	lookup = createLookup(aux, cpProvider);
229	}	224	}
230		225
Lines 339-345 Link Here
339	encodingQuery,	334	encodingQuery,
340	QuerySupport.createTemplateAttributesProvider(helper, encodingQuery),	335	QuerySupport.createTemplateAttributesProvider(helper, encodingQuery),
341	new RecommendedTemplatesImpl(this.updateHelper),	336	new RecommendedTemplatesImpl(this.updateHelper),
342	classPathExtender,	337	ProjectClassPathModifier.extenderForModifier(cpMod),
343	cpMod,	338	cpMod,
344	libMod,	339	libMod,
345	buildExtender,	340	buildExtender,
Lines 457-463 Link Here
457		452
458	if (fo.getParent ().equals (libFolder)) {	453	if (fo.getParent ().equals (libFolder)) {
459	try {	454	try {
460	classPathExtender.addArchiveFile(fo);	455	cpMod.addRoots(new URL[] {FileUtil.getArchiveRoot(fo.getURL())}, ProjectProperties.JAVAC_CLASSPATH);
461	} catch (IOException e) {	456	} catch (IOException e) {
462	Exceptions.printStackTrace(e);	457	Exceptions.printStackTrace(e);
463	}	458	}
Lines 585-599 Link Here
585	if (libFolderName != null && helper.resolveFile (libFolderName).isDirectory ()) {	580	if (libFolderName != null && helper.resolveFile (libFolderName).isDirectory ()) {
586	libFolder = helper.resolveFileObject(libFolderName);	581	libFolder = helper.resolveFileObject(libFolderName);
587	FileObject children [] = libFolder.getChildren ();	582	FileObject children [] = libFolder.getChildren ();
588	List<FileObject> libs = new LinkedList<FileObject>();	583	List<URL> libs = new LinkedList<URL>();
589	for (int i = 0; i < children.length; i++) {	584	for (int i = 0; i < children.length; i++) {
590	if (FileUtil.isArchiveFile(children[i])) {	585	if (FileUtil.isArchiveFile(children[i])) {
591	libs.add(children[i]);	586	libs.add(FileUtil.getArchiveRoot(children[i].getURL()));
592	}	587	}
593	}	588	}
594	FileObject[] libsArray = new FileObject[libs.size()];	589	cpMod.addRoots(libs.toArray(new URL[libs.size()]), ProjectProperties.JAVAC_CLASSPATH);
595	libs.toArray(libsArray);
596	classPathExtender.addArchiveFiles(ProjectProperties.JAVAC_CLASSPATH, libsArray, ClassPathSupportCallbackImpl.ELEMENT_INCLUDED_LIBRARIES);
597	libFolder.addFileChangeListener (AppClientProject.this);	590	libFolder.addFileChangeListener (AppClientProject.this);
598	}	591	}
599		592

Lines 52-57 Link Here

(-)a/j2ee.ejbjarproject/src/org/netbeans/modules/j2ee/ejbjarproject/EjbJarProject.java (-8 / +7 lines)
52	import java.io.IOException;	52	import java.io.IOException;
53	import java.io.InputStream;	53	import java.io.InputStream;
54	import java.io.OutputStream;	54	import java.io.OutputStream;
		55	import java.net.URL;
55	import java.util.ArrayList;	56	import java.util.ArrayList;
56	import java.util.Arrays;	57	import java.util.Arrays;
57	import java.util.Collections;	58	import java.util.Collections;
Lines 86-92 Link Here
86	import org.netbeans.modules.j2ee.common.SharabilityUtility;	87	import org.netbeans.modules.j2ee.common.SharabilityUtility;
87	import org.netbeans.modules.j2ee.common.Util;	88	import org.netbeans.modules.j2ee.common.Util;
88	import org.netbeans.modules.j2ee.common.project.ArtifactCopyOnSaveSupport;	89	import org.netbeans.modules.j2ee.common.project.ArtifactCopyOnSaveSupport;
89	import org.netbeans.modules.java.api.common.classpath.ClassPathExtender;
90	import org.netbeans.modules.java.api.common.classpath.ClassPathModifier;	90	import org.netbeans.modules.java.api.common.classpath.ClassPathModifier;
91	import org.netbeans.modules.java.api.common.classpath.ClassPathSupport;	91	import org.netbeans.modules.java.api.common.classpath.ClassPathSupport;
92	import org.netbeans.modules.java.api.common.classpath.ClassPathProviderImpl;	92	import org.netbeans.modules.java.api.common.classpath.ClassPathProviderImpl;
Lines 127-132 Link Here
127	import org.netbeans.modules.j2ee.common.project.ui.UserProjectSettings;	127	import org.netbeans.modules.j2ee.common.project.ui.UserProjectSettings;
128	import org.netbeans.modules.j2ee.deployment.devmodules.api.InstanceRemovedException;	128	import org.netbeans.modules.j2ee.deployment.devmodules.api.InstanceRemovedException;
129	import org.netbeans.api.j2ee.core.Profile;	129	import org.netbeans.api.j2ee.core.Profile;
		130	import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
130	import org.netbeans.api.project.ProjectUtils;	131	import org.netbeans.api.project.ProjectUtils;
131	import org.netbeans.modules.j2ee.deployment.devmodules.api.J2eeModule.Type;	132	import org.netbeans.modules.j2ee.deployment.devmodules.api.J2eeModule.Type;
132	import org.netbeans.modules.j2ee.deployment.devmodules.spi.ArtifactListener;	133	import org.netbeans.modules.j2ee.deployment.devmodules.spi.ArtifactListener;
Lines 205-211 Link Here
205	private EjbProjectJAXWSClientSupport jaxWsClientSupport;	206	private EjbProjectJAXWSClientSupport jaxWsClientSupport;
206	private SourceRoots sourceRoots;	207	private SourceRoots sourceRoots;
207	private SourceRoots testRoots;	208	private SourceRoots testRoots;
208	private final ClassPathExtender classPathExtender;
209	private final ClassPathModifier classPathModifier;	209	private final ClassPathModifier classPathModifier;
210	private PropertyChangeListener j2eePlatformListener;	210	private PropertyChangeListener j2eePlatformListener;
211	private AntBuildExtender buildExtender;	211	private AntBuildExtender buildExtender;
Lines 308-314 Link Here
308	classPathModifier = new ClassPathModifier(this, this.updateHelper, eval, refHelper,	308	classPathModifier = new ClassPathModifier(this, this.updateHelper, eval, refHelper,
309	new ClassPathSupportCallbackImpl(helper), createClassPathModifierCallback(),	309	new ClassPathSupportCallbackImpl(helper), createClassPathModifierCallback(),
310	getClassPathUiSupportCallback());	310	getClassPathUiSupportCallback());
311	classPathExtender = new ClassPathExtender(classPathModifier, ProjectProperties.JAVAC_CLASSPATH, ClassPathSupportCallbackImpl.ELEMENT_INCLUDED_LIBRARIES);
312	lookup = createLookup(aux, cpProvider);	311	lookup = createLookup(aux, cpProvider);
313	css = new CopyOnSaveSupport();	312	css = new CopyOnSaveSupport();
314	artifactSupport = new ArtifactCopySupport();	313	artifactSupport = new ArtifactCopySupport();
Lines 448-454 Link Here
448	encodingQuery,	447	encodingQuery,
449	new RecommendedTemplatesImpl(updateHelper),	448	new RecommendedTemplatesImpl(updateHelper),
450	refHelper,	449	refHelper,
451	classPathExtender,	450	ProjectClassPathModifier.extenderForModifier(classPathModifier),
452	classPathModifier,	451	classPathModifier,
453	new EjbJarProjectOperations(this),	452	new EjbJarProjectOperations(this),
454	new EjbJarPersistenceProvider(this, evaluator(), cpProvider),	453	new EjbJarPersistenceProvider(this, evaluator(), cpProvider),
Lines 691-697 Link Here
691		690
692	if (fo.getParent ().equals (libFolder)) {	691	if (fo.getParent ().equals (libFolder)) {
693	try {	692	try {
694	classPathExtender.addArchiveFile(fo);	693	classPathModifier.addRoots(new URL[] {FileUtil.getArchiveRoot(fo.getURL())}, ProjectProperties.JAVAC_CLASSPATH);
695	}	694	}
696	catch (IOException e) {	695	catch (IOException e) {
697	Exceptions.printStackTrace(e);	696	Exceptions.printStackTrace(e);
Lines 770-784 Link Here
770	if (libFolderName != null && helper.resolveFile (libFolderName).isDirectory ()) {	769	if (libFolderName != null && helper.resolveFile (libFolderName).isDirectory ()) {
771	libFolder = helper.resolveFileObject(libFolderName);	770	libFolder = helper.resolveFileObject(libFolderName);
772	FileObject[] children = libFolder.getChildren ();	771	FileObject[] children = libFolder.getChildren ();
773	List<FileObject> libs = new LinkedList<FileObject>();	772	List<URL> libs = new LinkedList<URL>();
774	for (int i = 0; i < children.length; i++) {	773	for (int i = 0; i < children.length; i++) {
775	if (FileUtil.isArchiveFile(children[i])) {	774	if (FileUtil.isArchiveFile(children[i])) {
776	libs.add(children[i]);	775	libs.add(FileUtil.getArchiveRoot(children[i].getURL()));
777	}	776	}
778	}	777	}
779	FileObject[] libsArray = new FileObject[libs.size()];	778	FileObject[] libsArray = new FileObject[libs.size()];
780	libs.toArray(libsArray);	779	libs.toArray(libsArray);
781	classPathExtender.addArchiveFiles(ProjectProperties.JAVAC_CLASSPATH, libsArray, ClassPathSupportCallbackImpl.ELEMENT_INCLUDED_LIBRARIES);	780	classPathModifier.addRoots(libs.toArray(new URL[libs.size()]), ProjectProperties.JAVAC_CLASSPATH);
782	libFolder.addFileChangeListener (EjbJarProject.this);	781	libFolder.addFileChangeListener (EjbJarProject.this);
783	}	782	}
784		783

Lines 75-80 Link Here

(-)a/java.j2seproject/src/org/netbeans/modules/java/j2seproject/J2SEProject.java (-3 / +2 lines)
75	import org.netbeans.api.java.classpath.ClassPath;	75	import org.netbeans.api.java.classpath.ClassPath;
76	import org.netbeans.api.java.classpath.GlobalPathRegistry;	76	import org.netbeans.api.java.classpath.GlobalPathRegistry;
77	import org.netbeans.api.java.project.JavaProjectConstants;	77	import org.netbeans.api.java.project.JavaProjectConstants;
		78	import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
78	import org.netbeans.api.project.Project;	79	import org.netbeans.api.project.Project;
79	import org.netbeans.api.project.ProjectManager;	80	import org.netbeans.api.project.ProjectManager;
80	import org.netbeans.api.project.SourceGroup;	81	import org.netbeans.api.project.SourceGroup;
Lines 341-348 Link Here
341	private Lookup createLookup(final AuxiliaryConfiguration aux,	342	private Lookup createLookup(final AuxiliaryConfiguration aux,
342	final J2SEActionProvider actionProvider) {	343	final J2SEActionProvider actionProvider) {
343	FileEncodingQueryImplementation encodingQuery = QuerySupport.createFileEncodingQuery(evaluator(), J2SEProjectProperties.SOURCE_ENCODING);	344	FileEncodingQueryImplementation encodingQuery = QuerySupport.createFileEncodingQuery(evaluator(), J2SEProjectProperties.SOURCE_ENCODING);
344	@SuppressWarnings("deprecation") Object cpe = new org.netbeans.modules.java.api.common.classpath.ClassPathExtender(
345	cpMod, ProjectProperties.JAVAC_CLASSPATH, null);
346	final Lookup base = Lookups.fixed(	345	final Lookup base = Lookups.fixed(
347	J2SEProject.this,	346	J2SEProject.this,
348	QuerySupport.createProjectInformation(updateHelper, this, J2SE_PROJECT_ICON),	347	QuerySupport.createProjectInformation(updateHelper, this, J2SE_PROJECT_ICON),
Lines 366-372 Link Here
366	QuerySupport.createSharabilityQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()),	365	QuerySupport.createSharabilityQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()),
367	new CoSAwareFileBuiltQueryImpl(QuerySupport.createFileBuiltQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()), this),	366	new CoSAwareFileBuiltQueryImpl(QuerySupport.createFileBuiltQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()), this),
368	new RecommendedTemplatesImpl (this.updateHelper),	367	new RecommendedTemplatesImpl (this.updateHelper),
369	cpe,	368	ProjectClassPathModifier.extenderForModifier(cpMod),
370	buildExtender,	369	buildExtender,
371	cpMod,	370	cpMod,
372	new J2SEProjectOperations(this, actionProvider),	371	new J2SEProjectOperations(this, actionProvider),

Lines 109-114 Link Here

(-)a/java.project/apichanges.xml (+21 lines)
109	<!-- ACTUAL CHANGES BEGIN HERE: -->	109	<!-- ACTUAL CHANGES BEGIN HERE: -->
110		110
111	<changes>	111	<changes>
		112	<change id="ProjectClassPathModifier.extenderForModifier">
		113	<api name="classpath"/>
		114	<summary>Added <code>ProjectClassPathModifier.extenderForModifier</code></summary>
		115	<version major="1" minor="41"/>
		116	<date day="22" month="8" year="2011"/>
		117	<author login="jglick"/>
		118	<compatibility addition="yes">
		119	<p>
		120	Any modules still implementing <code>ProjectClassPathExtender</code> should cease to do so.
		121	</p>
		122	</compatibility>
		123	<description>
		124	<p>
		125	Added a bridge from an old SPI to the newer, preferred SPI.
		126	Also added <code>LookupMergerSupport.createClassPathModifierMerger</code>.
		127	</p>
		128	</description>
		129	<class package="org.netbeans.api.java.project.classpath" name="ProjectClassPathModifier"/>
		130	<class package="org.netbeans.spi.java.project.support" name="LookupMergerSupport"/>
		131	<issue number="196455"/>
		132	</change>
112	<change id="JAVA_ICON">	133	<change id="JAVA_ICON">
113	<api name="general"/>	134	<api name="general"/>
114	<summary>Added <code>JavaTemplates.JAVA_ICON</code></summary>	135	<summary>Added <code>JavaTemplates.JAVA_ICON</code></summary>

Line 0 Link Here

(-)a/java.project/src/org/netbeans/modules/java/project/classpath/ClassPathModifierLookupMerger.java (+194 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2010 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2008 Sun Microsystems, Inc.
		41	*/
		42
		43	package org.netbeans.modules.java.project.classpath;
		44
		45	import java.io.IOException;
		46	import java.net.URI;
		47	import java.net.URL;
		48	import java.util.Arrays;
		49	import java.util.Collection;
		50	import java.util.LinkedHashSet;
		51	import org.netbeans.api.project.Project;
		52	import org.netbeans.api.project.SourceGroup;
		53	import org.netbeans.api.project.ant.AntArtifact;
		54	import org.netbeans.api.project.libraries.Library;
		55	import org.netbeans.spi.java.project.classpath.ProjectClassPathModifierImplementation;
		56	import org.netbeans.spi.project.LookupMerger;
		57	import org.openide.util.Lookup;
		58
		59	public class ClassPathModifierLookupMerger implements LookupMerger<ProjectClassPathModifierImplementation>{
		60
		61	@Override public Class<ProjectClassPathModifierImplementation> getMergeableClass() {
		62	return ProjectClassPathModifierImplementation.class;
		63	}
		64
65	@Override public ProjectClassPathModifierImplementation merge(Lookup lookup) {
66	return new Modifier(lookup);
67	}
68
69	private static class Modifier extends ProjectClassPathModifierImplementation {
70
71	private final Lookup context;
72
73	private Modifier(Lookup context) {
74	this.context = context;
75	}
76
77	@Override protected SourceGroup[] getExtensibleSourceGroups() {
78	Collection<SourceGroup> sgs = new LinkedHashSet<SourceGroup>();
79	for (ProjectClassPathModifierImplementation impl : context.lookupAll(ProjectClassPathModifierImplementation.class)) {
80	sgs.addAll(Arrays.asList(ProjectClassPathModifierAccessor.INSTANCE.getExtensibleSourceGroups(impl)));
81	}
82	return sgs.toArray(new SourceGroup[sgs.size()]);
83	}
84
85	@Override protected String[] getExtensibleClassPathTypes(SourceGroup sourceGroup) {
86	Collection<String> types = new LinkedHashSet<String>();
87	for (ProjectClassPathModifierImplementation impl : context.lookupAll(ProjectClassPathModifierImplementation.class)) {
88	types.addAll(Arrays.asList(ProjectClassPathModifierAccessor.INSTANCE.getExtensibleClassPathTypes(impl, sourceGroup)));
89	}
90	return types.toArray(new String[types.size()]);
91	}
92
93	private interface Op {
94	boolean run(ProjectClassPathModifierImplementation impl) throws IOException, UnsupportedOperationException;
95	}
96
97	private boolean run(Op op) throws IOException, UnsupportedOperationException {
98	boolean completedNormally = false;
99	UnsupportedOperationException uoe = null;
100	for (ProjectClassPathModifierImplementation impl : context.lookupAll(ProjectClassPathModifierImplementation.class)) {
101	try {
102	if (op.run(impl)) {
103	return true;
104	} else {
105	completedNormally = true;
106	}
107	} catch (UnsupportedOperationException x) {
108	uoe = x;
109	}
110	}
111	if (uoe != null && !completedNormally) {
112	throw uoe;
113	} else {
114	return false;
115	}
116	}
117
118	// closures would be handy here...
119
120	@Override protected boolean addLibraries(final Library[] libraries, final SourceGroup sourceGroup, final String type) throws IOException, UnsupportedOperationException {
121	return run(new Op() {
122	@Override public boolean run(ProjectClassPathModifierImplementation impl) throws IOException, UnsupportedOperationException {
123	return ProjectClassPathModifierAccessor.INSTANCE.addLibraries(libraries, impl, sourceGroup, type);
124	}
125	});
126	}
127
128	@Override protected boolean removeLibraries(final Library[] libraries, final SourceGroup sourceGroup, final String type) throws IOException, UnsupportedOperationException {
129	return run(new Op() {
130	@Override public boolean run(ProjectClassPathModifierImplementation impl) throws IOException, UnsupportedOperationException {
131	return ProjectClassPathModifierAccessor.INSTANCE.removeLibraries(libraries, impl, sourceGroup, type);
132	}
133	});
134	}
135
136	@Override protected boolean addRoots(final URL[] classPathRoots, final SourceGroup sourceGroup, final String type) throws IOException, UnsupportedOperationException {
137	return run(new Op() {
138	@Override public boolean run(ProjectClassPathModifierImplementation impl) throws IOException, UnsupportedOperationException {
139	return ProjectClassPathModifierAccessor.INSTANCE.addRoots(classPathRoots, impl, sourceGroup, type);
140	}
141	});
142	}
143
144	@Override protected boolean removeRoots(final URL[] classPathRoots, final SourceGroup sourceGroup, final String type) throws IOException, UnsupportedOperationException {
145	return run(new Op() {
146	@Override public boolean run(ProjectClassPathModifierImplementation impl) throws IOException, UnsupportedOperationException {
147	return ProjectClassPathModifierAccessor.INSTANCE.removeRoots(classPathRoots, impl, sourceGroup, type);
148	}
149	});
150	}
151
152	@Override protected boolean addRoots(final URI[] classPathRoots, final SourceGroup sourceGroup, final String type) throws IOException, UnsupportedOperationException {
153	return run(new Op() {
154	@Override public boolean run(ProjectClassPathModifierImplementation impl) throws IOException, UnsupportedOperationException {
155	return ProjectClassPathModifierAccessor.INSTANCE.addRoots(classPathRoots, impl, sourceGroup, type);
156	}
157	});
158	}
159
160	@Override protected boolean removeRoots(final URI[] classPathRoots, final SourceGroup sourceGroup, final String type) throws IOException, UnsupportedOperationException {
161	return run(new Op() {
162	@Override public boolean run(ProjectClassPathModifierImplementation impl) throws IOException, UnsupportedOperationException {
163	return ProjectClassPathModifierAccessor.INSTANCE.removeRoots(classPathRoots, impl, sourceGroup, type);
164	}
165	});
166	}
167
168	@Override protected boolean addAntArtifacts(final AntArtifact[] artifacts, final URI[] artifactElements, final SourceGroup sourceGroup, final String type) throws IOException, UnsupportedOperationException {
169	return run(new Op() {
170	@Override public boolean run(ProjectClassPathModifierImplementation impl) throws IOException, UnsupportedOperationException {
171	return ProjectClassPathModifierAccessor.INSTANCE.addAntArtifacts(artifacts, artifactElements, impl, sourceGroup, type);
172	}
173	});
174	}
175
176	@Override protected boolean removeAntArtifacts(final AntArtifact[] artifacts, final URI[] artifactElements, final SourceGroup sourceGroup, final String type) throws IOException, UnsupportedOperationException {
177	return run(new Op() {
178	@Override public boolean run(ProjectClassPathModifierImplementation impl) throws IOException, UnsupportedOperationException {
179	return ProjectClassPathModifierAccessor.INSTANCE.removeAntArtifacts(artifacts, artifactElements, impl, sourceGroup, type);
180	}
181	});
182	}
183
184	@Override protected boolean addProjects(final Project[] projects, final SourceGroup sourceGroup, final String type) throws IOException, UnsupportedOperationException {
185	return run(new Op() {
186	@Override public boolean run(ProjectClassPathModifierImplementation impl) throws IOException, UnsupportedOperationException {
187	return ProjectClassPathModifierAccessor.INSTANCE.addProjects(projects, impl, sourceGroup, type);
188	}
189	});
190	}
191
192	}
193
194	}

Lines 46-51 Link Here

(-)a/java.project/src/org/netbeans/spi/java/project/classpath/ProjectClassPathExtender.java (-4 / +6 lines)
46		46
47	import java.io.IOException;	47	import java.io.IOException;
48	import java.net.URI;	48	import java.net.URI;
		49	import java.net.URL;
49	import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;	50	import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
50	import org.netbeans.api.project.ant.AntArtifact;	51	import org.netbeans.api.project.ant.AntArtifact;
51	import org.netbeans.api.project.libraries.Library;	52	import org.netbeans.api.project.libraries.Library;
Lines 57-63 Link Here
57	* allow clients to extend its compilation classpath	58	* allow clients to extend its compilation classpath
58	* by a new classpath element (JAR, folder, dependent project, or library).	59	* by a new classpath element (JAR, folder, dependent project, or library).
59	* @since org.netbeans.modules.java.project/1 1.3	60	* @since org.netbeans.modules.java.project/1 1.3
60	* @deprecated Please use {@link ProjectClassPathModifier} instead.	61	* @deprecated As a caller, use {@link ProjectClassPathModifier} instead.
		62	* As an implementor, use {@link ProjectClassPathModifier#extenderForModifier}.
61	*/	63	*/
62	@Deprecated	64	@Deprecated
63	public interface ProjectClassPathExtender {	65	public interface ProjectClassPathExtender {
Lines 68-74 Link Here
68	* @param library to be added	70	* @param library to be added
69	* @return true in case the classpath was changed	71	* @return true in case the classpath was changed
70	* @exception IOException in case the project metadata cannot be changed	72	* @exception IOException in case the project metadata cannot be changed
71	* @deprecated Please use {@link ProjectClassPathModifier#addLibrary} instead.	73	* @deprecated Please use {@link ProjectClassPathModifier#addLibraries} instead.
72	*/	74	*/
73	@Deprecated	75	@Deprecated
74	boolean addLibrary(Library library) throws IOException;	76	boolean addLibrary(Library library) throws IOException;
Lines 79-85 Link Here
79	* @param archiveFile ZIP/JAR file to be added	81	* @param archiveFile ZIP/JAR file to be added
80	* @return true in case the classpath was changed	82	* @return true in case the classpath was changed
81	* @exception IOException in case the project metadata cannot be changed	83	* @exception IOException in case the project metadata cannot be changed
82	* @deprecated Please use {@link ProjectClassPathModifier#addArchive} instead.	84	* @deprecated Please use {@link ProjectClassPathModifier#addRoots(URL[], FileObject, String)} instead.
83	*/	85	*/
84	@Deprecated	86	@Deprecated
85	boolean addArchiveFile(FileObject archiveFile) throws IOException;	87	boolean addArchiveFile(FileObject archiveFile) throws IOException;
Lines 92-98 Link Here
92	* (must be owned by the artifact and be relative to it)	94	* (must be owned by the artifact and be relative to it)
93	* @return true in case the classpath was changed	95	* @return true in case the classpath was changed
94	* @exception IOException in case the project metadata cannot be changed	96	* @exception IOException in case the project metadata cannot be changed
95	* @deprecated Please use {@link ProjectClassPathModifier#addAntArtifact} instead.	97	* @deprecated Please use {@link ProjectClassPathModifier#addAntArtifacts} instead.
96	*/	98	*/
97	@Deprecated	99	@Deprecated
98	boolean addAntArtifact(AntArtifact artifact, URI artifactElement) throws IOException;	100	boolean addAntArtifact(AntArtifact artifact, URI artifactElement) throws IOException;

Lines 42-47 Link Here

(-)a/java.project/src/org/netbeans/spi/java/project/support/LookupMergerSupport.java (-1 / +17 lines)
42		42
43	package org.netbeans.spi.java.project.support;	43	package org.netbeans.spi.java.project.support;
44		44
		45	import java.io.IOException;
45	import java.net.URL;	46	import java.net.URL;
46	import java.util.Arrays;	47	import java.util.Arrays;
47	import java.util.Collection;	48	import java.util.Collection;
Lines 54-60 Link Here
54	import org.netbeans.api.java.queries.JavadocForBinaryQuery;	55	import org.netbeans.api.java.queries.JavadocForBinaryQuery;
55	import org.netbeans.api.java.queries.SourceForBinaryQuery;	56	import org.netbeans.api.java.queries.SourceForBinaryQuery;
56	import org.netbeans.api.project.ProjectManager;	57	import org.netbeans.api.project.ProjectManager;
		58	import org.netbeans.modules.java.project.classpath.ClassPathModifierLookupMerger;
57	import org.netbeans.spi.java.classpath.ClassPathProvider;	59	import org.netbeans.spi.java.classpath.ClassPathProvider;
		60	import org.netbeans.spi.java.project.classpath.ProjectClassPathModifierImplementation;
58	import org.netbeans.spi.java.queries.JavadocForBinaryQueryImplementation;	61	import org.netbeans.spi.java.queries.JavadocForBinaryQueryImplementation;
59	import org.netbeans.spi.java.queries.SourceForBinaryQueryImplementation;	62	import org.netbeans.spi.java.queries.SourceForBinaryQueryImplementation;
60	import org.netbeans.spi.java.queries.SourceForBinaryQueryImplementation2;	63	import org.netbeans.spi.java.queries.SourceForBinaryQueryImplementation2;
Lines 106-112 Link Here
106	public static LookupMerger<ClassPathProvider> createClassPathProviderMerger(ClassPathProvider defaultProvider) {	109	public static LookupMerger<ClassPathProvider> createClassPathProviderMerger(ClassPathProvider defaultProvider) {
107	return new ClassPathProviderMerger(defaultProvider);	110	return new ClassPathProviderMerger(defaultProvider);
108	}	111	}
109		112
		113	/**
		114	* Creates a merger of class path modifiers.
		115	* All supported source groups and classpath types are unified.
		116	* The first modifier implementation to return true (or throw {@link IOException}) is accepted.
		117	* False is returned if all of the implementations do so.
		118	* {@link UnsupportedOperationException} is thrown only if all of the implementations do so.
		119	* @return a merger
		120	* @since 1.41
		121	*/
		122	public static LookupMerger<ProjectClassPathModifierImplementation> createClassPathModifierMerger() {
		123	return new ClassPathModifierLookupMerger();
		124	}
		125
110	private static class SFBLookupMerger implements LookupMerger<SourceForBinaryQueryImplementation> {	126	private static class SFBLookupMerger implements LookupMerger<SourceForBinaryQueryImplementation> {
111		127
112	public Class<SourceForBinaryQueryImplementation> getMergeableClass() {	128	public Class<SourceForBinaryQueryImplementation> getMergeableClass() {

Lines 53-71 Link Here

(-)a/maven.persistence/src/org/netbeans/modules/maven/persistence/CPExtender.java (-9 / +12 lines)
53	import org.netbeans.api.project.ant.AntArtifact;	53	import org.netbeans.api.project.ant.AntArtifact;
54	import org.netbeans.api.project.libraries.Library;	54	import org.netbeans.api.project.libraries.Library;
55	import org.netbeans.modules.maven.api.ModelUtils;	55	import org.netbeans.modules.maven.api.ModelUtils;
56	import org.netbeans.spi.java.project.classpath.ProjectClassPathExtender;
57	import org.netbeans.spi.java.project.classpath.ProjectClassPathModifierImplementation;	56	import org.netbeans.spi.java.project.classpath.ProjectClassPathModifierImplementation;
58	import org.netbeans.spi.project.ProjectServiceProvider;	57	import org.netbeans.spi.project.ProjectServiceProvider;
59	import org.openide.filesystems.FileObject;
60	import org.openide.util.Exceptions;	58	import org.openide.util.Exceptions;
61		59
62	/**	60	/**
63	*	61	*
64	* @author mkleint	62	* @author mkleint
65	*/	63	*/
66	@ProjectServiceProvider(service={ProjectClassPathModifierImplementation.class, ProjectClassPathExtender.class},	64	@ProjectServiceProvider(service=ProjectClassPathModifierImplementation.class,
67	projectType="org-netbeans-modules-maven")	65	projectType="org-netbeans-modules-maven")
68	public class CPExtender extends ProjectClassPathModifierImplementation implements ProjectClassPathExtender {	66	public class CPExtender extends ProjectClassPathModifierImplementation {
69	private static final String SL_15 = "1.5"; //NOI18N	67	private static final String SL_15 = "1.5"; //NOI18N
70	private Project project;	68	private Project project;
71	/** Creates a new instance of CPExtender */	69	/** Creates a new instance of CPExtender */
Lines 119-125 Link Here
119	return false;	117	return false;
120	}	118	}
121		119
122	public boolean addLibrary(Library library) throws IOException {	120	private boolean addLibrary(Library library) throws IOException {
123	if ("toplink".equals(library.getName())) { //NOI18N	121	if ("toplink".equals(library.getName())) { //NOI18N
124	//TODO would be nice if the toplink lib shipping with netbeans be the same binary	122	//TODO would be nice if the toplink lib shipping with netbeans be the same binary
125	// then we could just copy the pieces to local repo.	123	// then we could just copy the pieces to local repo.
Lines 130-135 Link Here
130	ModelHandle handle = ModelHandleUtils.createModelHandle(project);	128	ModelHandle handle = ModelHandleUtils.createModelHandle(project);
131		129
132	// checking source doesn't work anymore, the wizard requires the level to be 1.5 up front.	130	// checking source doesn't work anymore, the wizard requires the level to be 1.5 up front.
		131	// XXX this seems wrong; what if the source level is already 1.6 or higher? (or "5" or "6"?)
133	ModelUtils.checkSourceLevel(handle, SL_15);	132	ModelUtils.checkSourceLevel(handle, SL_15);
134	ModelHandleUtils.writeModelHandle(handle, project);	133	ModelHandleUtils.writeModelHandle(handle, project);
135		134
Lines 142-153 Link Here
142	}	141	}
143	return false;	142	return false;
144	}	143	}
145		144
146	public boolean addArchiveFile(FileObject arg0) throws IOException {	145	@Override protected boolean addRoots(URI[] classPathRoots, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException {
147	return false;	146	return false;
148	}	147	}
149		148
150	public boolean addAntArtifact(AntArtifact arg0, URI arg1) throws IOException {	149	@Override protected boolean removeRoots(URI[] classPathRoots, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException {
		150	return false;
		151	}
		152
		153	@Override protected boolean addProjects(Project[] projects, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException {
151	return false;	154	return false;
152	}	155	}
153		156

Lines 87-92 Link Here

(-)a/maven/src/org/netbeans/modules/maven/NbMavenProjectImpl.java (-4 / +5 lines)
87	import org.netbeans.api.annotations.common.CheckForNull;	87	import org.netbeans.api.annotations.common.CheckForNull;
88	import org.netbeans.api.annotations.common.NonNull;	88	import org.netbeans.api.annotations.common.NonNull;
89	import org.netbeans.api.java.project.JavaProjectConstants;	89	import org.netbeans.api.java.project.JavaProjectConstants;
		90	import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
90	import org.netbeans.api.project.Project;	91	import org.netbeans.api.project.Project;
91	import org.netbeans.api.project.ProjectInformation;	92	import org.netbeans.api.project.ProjectInformation;
92	import org.netbeans.api.project.ProjectManager;	93	import org.netbeans.api.project.ProjectManager;
Lines 99-106 Link Here
99	import org.netbeans.modules.maven.api.PluginPropertyUtils;	100	import org.netbeans.modules.maven.api.PluginPropertyUtils;
100	import org.netbeans.modules.maven.api.problem.ProblemReport;	101	import org.netbeans.modules.maven.api.problem.ProblemReport;
101	import org.netbeans.modules.maven.classpath.CPExtender;	102	import org.netbeans.modules.maven.classpath.CPExtender;
102	import org.netbeans.modules.maven.classpath.CPExtenderLookupMerger;
103	import org.netbeans.modules.maven.classpath.CPModifierLookupMerger;
104	import org.netbeans.modules.maven.classpath.ClassPathProviderImpl;	103	import org.netbeans.modules.maven.classpath.ClassPathProviderImpl;
105	import org.netbeans.modules.maven.classpath.MavenSourcesImpl;	104	import org.netbeans.modules.maven.classpath.MavenSourcesImpl;
106	import org.netbeans.modules.maven.configurations.M2ConfigProvider;	105	import org.netbeans.modules.maven.configurations.M2ConfigProvider;
Lines 128-133 Link Here
128	import org.netbeans.modules.maven.queries.MavenSharabilityQueryImpl;	127	import org.netbeans.modules.maven.queries.MavenSharabilityQueryImpl;
129	import org.netbeans.modules.maven.queries.MavenSourceLevelImpl;	128	import org.netbeans.modules.maven.queries.MavenSourceLevelImpl;
130	import org.netbeans.modules.maven.queries.MavenTestForSourceImpl;	129	import org.netbeans.modules.maven.queries.MavenTestForSourceImpl;
		130	import org.netbeans.spi.java.project.support.LookupMergerSupport;
131	import org.netbeans.spi.project.LookupMerger;	131	import org.netbeans.spi.project.LookupMerger;
132	import org.netbeans.spi.project.ProjectState;	132	import org.netbeans.spi.project.ProjectState;
133	import org.netbeans.spi.project.SubprojectProvider;	133	import org.netbeans.spi.project.SubprojectProvider;
Lines 909-916 Link Here
909	UILookupMergerSupport.createPrivilegedTemplatesMerger(),	909	UILookupMergerSupport.createPrivilegedTemplatesMerger(),
910	UILookupMergerSupport.createRecommendedTemplatesMerger(),	910	UILookupMergerSupport.createRecommendedTemplatesMerger(),
911	LookupProviderSupport.createSourcesMerger(),	911	LookupProviderSupport.createSourcesMerger(),
912	new CPExtenderLookupMerger(extender),	912	ProjectClassPathModifier.extenderForModifier(this),
913	new CPModifierLookupMerger(extender),	913	extender,
		914	LookupMergerSupport.createClassPathModifierMerger(),
914	new BackwardCompatibilityWithMevenideChecker(),	915	new BackwardCompatibilityWithMevenideChecker(),
915	new DebuggerChecker(),	916	new DebuggerChecker(),
916	new CosChecker(this),	917	new CosChecker(this),

Lines 85-92 Link Here

(-)a/maven/src/org/netbeans/modules/maven/classpath/CPExtender.java (-52 / +1 lines)
85	* maven dependencies to the way classpath items are added through this api.	85	* maven dependencies to the way classpath items are added through this api.
86	* @author mkleint	86	* @author mkleint
87	*/	87	*/
88	@SuppressWarnings("deprecation")	88	public class CPExtender extends ProjectClassPathModifierImplementation {
89	public class CPExtender extends ProjectClassPathModifierImplementation implements org.netbeans.spi.java.project.classpath.ProjectClassPathExtender {
90		89
91	private NbMavenProjectImpl project;	90	private NbMavenProjectImpl project;
92	private static final String POM_XML = "pom.xml"; //NOI18N	91	private static final String POM_XML = "pom.xml"; //NOI18N
Lines 105-156 Link Here
105	this.project = project;	104	this.project = project;
106	}	105	}
107		106
108	public boolean addLibrary(final Library library) throws IOException {
109	final Boolean[] added = new Boolean[1];
110	ModelOperation<POMModel> operation = new ModelOperation<POMModel>() {
111	public void performOperation(POMModel model) {
112	try {
113	added[0] = addRemoveLibrary(library, model, null, true);
114	} catch (IOException ex) {
115	Exceptions.printStackTrace(ex);
116	added[0] = Boolean.FALSE;
117	}
118	}
119	};
120	FileObject pom = project.getProjectDirectory().getFileObject(POM_XML);//NOI18N
121	org.netbeans.modules.maven.model.Utilities.performPOMModelOperations(pom, Collections.singletonList(operation));
122	//TODO is the manual reload necessary if pom.xml file is being saved?
123	// NbMavenProject.fireMavenProjectReload(project);
124	if (added[0]) {
125	project.getLookup().lookup(NbMavenProject.class).triggerDependencyDownload();
126	}
127
128	return added[0];
129	}
130
131	public boolean addArchiveFile(FileObject arch) throws IOException {
132	final File jar = FileUtil.archiveOrDirForURL(arch.getURL());
133	if (jar == null \|\| jar.isDirectory()) {
134	throw new IOException("Cannot add folders to Maven projects as dependencies: " + arch); //NOI18N
135	}
136	final AtomicBoolean added = new AtomicBoolean();
137	ModelOperation<POMModel> operation = new ModelOperation<POMModel>() {
138	public void performOperation(POMModel model) {
139	try {
140	added.compareAndSet(false, addRemoveJAR(jar, model, null, true));
141	} catch (IOException ex) {
142	Exceptions.printStackTrace(ex);
143	}
144	}
145	};
146	FileObject pom = project.getProjectDirectory().getFileObject(POM_XML);//NOI18N
147	org.netbeans.modules.maven.model.Utilities.performPOMModelOperations(pom, Collections.singletonList(operation));
148	if (added.get()) {
149	project.getLookup().lookup(NbMavenProject.class).triggerDependencyDownload();
150	}
151	return added.get();
152	}
153
154	private boolean addRemoveLibrary(Library library, POMModel model, String scope, boolean add) throws IOException {	107	private boolean addRemoveLibrary(Library library, POMModel model, String scope, boolean add) throws IOException {
155	Boolean modified = checkLibraryForPoms(library, model, scope, add);	108	Boolean modified = checkLibraryForPoms(library, model, scope, add);
156	if (modified == null) {	109	if (modified == null) {
Lines 260-269 Link Here
260	return modified;	213	return modified;
261	}	214	}
262		215
263	public boolean addAntArtifact(AntArtifact arg0, URI arg1) throws IOException {
264	throw new IOException("Cannot add Ant based projects as subprojecs to Maven projects."); //NOI18N
265	}
266
267	public SourceGroup[] getExtensibleSourceGroups() {	216	public SourceGroup[] getExtensibleSourceGroups() {
268	Sources s = this.project.getLookup().lookup(Sources.class);	217	Sources s = this.project.getLookup().lookup(Sources.class);
269	assert s != null;	218	assert s != null;

Lines 216-230 Link Here

(-)a/web.project/nbproject/project.xml (-10 / +10 lines)
216	</run-dependency>	216	</run-dependency>
217	</dependency>	217	</dependency>
218	<dependency>	218	<dependency>
219	<code-name-base>org.netbeans.modules.javaee.specs.support</code-name-base>
220	<build-prerequisite/>
221	<compile-dependency/>
222	<run-dependency>
223	<release-version>0</release-version>
224	<specification-version>1.0</specification-version>
225	</run-dependency>
226	</dependency>
227	<dependency>
228	<code-name-base>org.netbeans.modules.j2eeserver</code-name-base>	219	<code-name-base>org.netbeans.modules.j2eeserver</code-name-base>
229	<build-prerequisite/>	220	<build-prerequisite/>
230	<compile-dependency/>	221	<compile-dependency/>
Lines 256-262 Link Here
256	<compile-dependency/>	247	<compile-dependency/>
257	<run-dependency>	248	<run-dependency>
258	<release-version>1</release-version>	249	<release-version>1</release-version>
259	<specification-version>1.37</specification-version>	250	<specification-version>1.41</specification-version>
260	</run-dependency>	251	</run-dependency>
261	</dependency>	252	</dependency>
262	<dependency>	253	<dependency>
Lines 268-273 Link Here
268	</run-dependency>	259	</run-dependency>
269	</dependency>	260	</dependency>
270	<dependency>	261	<dependency>
		262	<code-name-base>org.netbeans.modules.javaee.specs.support</code-name-base>
		263	<build-prerequisite/>
		264	<compile-dependency/>
		265	<run-dependency>
		266	<release-version>0</release-version>
		267	<specification-version>1.0</specification-version>
		268	</run-dependency>
		269	</dependency>
		270	<dependency>
271	<code-name-base>org.netbeans.modules.junit</code-name-base>	271	<code-name-base>org.netbeans.modules.junit</code-name-base>
272	<run-dependency>	272	<run-dependency>
273	<release-version>2</release-version>	273	<release-version>2</release-version>

Lines 59-65 Link Here

(-)a/web.project/src/org/netbeans/modules/web/project/WebProject.java (-8 / +2 lines)
59	import java.util.zip.ZipEntry;	59	import java.util.zip.ZipEntry;
60	import java.util.zip.ZipFile;	60	import java.util.zip.ZipFile;
61	import javax.swing.Icon;	61	import javax.swing.Icon;
62	import javax.swing.JButton;
63	import javax.swing.event.ChangeEvent;	62	import javax.swing.event.ChangeEvent;
64	import javax.swing.event.ChangeListener;	63	import javax.swing.event.ChangeListener;
65	import org.netbeans.api.java.classpath.ClassPath;	64	import org.netbeans.api.java.classpath.ClassPath;
Lines 68-77 Link Here
68	import org.netbeans.api.project.ant.AntBuildExtender;	67	import org.netbeans.api.project.ant.AntBuildExtender;
69	import org.netbeans.api.queries.FileBuiltQuery.Status;	68	import org.netbeans.api.queries.FileBuiltQuery.Status;
70	import org.netbeans.api.j2ee.core.Profile;	69	import org.netbeans.api.j2ee.core.Profile;
		70	import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
71	import org.netbeans.modules.j2ee.dd.api.ejb.EjbJarMetadata;	71	import org.netbeans.modules.j2ee.dd.api.ejb.EjbJarMetadata;
72	import org.netbeans.modules.j2ee.metadata.model.api.MetadataModelAction;	72	import org.netbeans.modules.j2ee.metadata.model.api.MetadataModelAction;
73	import org.netbeans.modules.java.api.common.Roots;	73	import org.netbeans.modules.java.api.common.Roots;
74	import org.netbeans.modules.java.api.common.classpath.ClassPathSupport.Item;
75	import org.netbeans.modules.j2ee.deployment.devmodules.spi.ArtifactListener.Artifact;	74	import org.netbeans.modules.j2ee.deployment.devmodules.spi.ArtifactListener.Artifact;
76	import org.netbeans.modules.web.common.spi.ProjectWebRootProvider;	75	import org.netbeans.modules.web.common.spi.ProjectWebRootProvider;
77	import org.netbeans.modules.web.jsfapi.spi.JsfSupportHandle;	76	import org.netbeans.modules.web.jsfapi.spi.JsfSupportHandle;
Lines 118-124 Link Here
118	import org.netbeans.modules.j2ee.common.Util;	117	import org.netbeans.modules.j2ee.common.Util;
119	import org.netbeans.modules.j2ee.common.dd.DDHelper;	118	import org.netbeans.modules.j2ee.common.dd.DDHelper;
120	import org.netbeans.modules.j2ee.common.project.ArtifactCopyOnSaveSupport;	119	import org.netbeans.modules.j2ee.common.project.ArtifactCopyOnSaveSupport;
121	import org.netbeans.modules.java.api.common.classpath.ClassPathExtender;
122	import org.netbeans.modules.java.api.common.classpath.ClassPathModifier;	120	import org.netbeans.modules.java.api.common.classpath.ClassPathModifier;
123	import org.netbeans.modules.java.api.common.classpath.ClassPathModifierSupport;	121	import org.netbeans.modules.java.api.common.classpath.ClassPathModifierSupport;
124	import org.netbeans.modules.j2ee.deployment.devmodules.api.J2eePlatform;	122	import org.netbeans.modules.j2ee.deployment.devmodules.api.J2eePlatform;
Lines 176-183 Link Here
176	import org.netbeans.spi.project.support.ant.PropertyProvider;	174	import org.netbeans.spi.project.support.ant.PropertyProvider;
177	import org.netbeans.spi.project.support.ant.PropertyUtils;	175	import org.netbeans.spi.project.support.ant.PropertyUtils;
178	import org.netbeans.spi.queries.FileEncodingQueryImplementation;	176	import org.netbeans.spi.queries.FileEncodingQueryImplementation;
179	import org.openide.DialogDisplayer;
180	import org.openide.NotifyDescriptor;
181	import org.openide.filesystems.FileLock;	177	import org.openide.filesystems.FileLock;
182	import org.openide.filesystems.FileSystem;	178	import org.openide.filesystems.FileSystem;
183	import org.openide.filesystems.FileSystem.AtomicAction;	179	import org.openide.filesystems.FileSystem.AtomicAction;
Lines 226-232 Link Here
226	private final UpdateHelper updateHelper;	222	private final UpdateHelper updateHelper;
227	private final UpdateProjectImpl updateProject;	223	private final UpdateProjectImpl updateProject;
228	private final AuxiliaryConfiguration aux;	224	private final AuxiliaryConfiguration aux;
229	private final ClassPathExtender classPathExtender;
230	private final ClassPathModifier cpMod;	225	private final ClassPathModifier cpMod;
231	private final WebProjectLibrariesModifierImpl libMod;	226	private final WebProjectLibrariesModifierImpl libMod;
232	private final ClassPathProviderImpl cpProvider;	227	private final ClassPathProviderImpl cpProvider;
Lines 392-398 Link Here
392	cpMod = new ClassPathModifier(this, this.updateHelper, eval, refHelper,	387	cpMod = new ClassPathModifier(this, this.updateHelper, eval, refHelper,
393	new ClassPathSupportCallbackImpl(helper), createClassPathModifierCallback(), getClassPathUiSupportCallback());	388	new ClassPathSupportCallbackImpl(helper), createClassPathModifierCallback(), getClassPathUiSupportCallback());
394	libMod = new WebProjectLibrariesModifierImpl(this, this.updateHelper, eval, refHelper);	389	libMod = new WebProjectLibrariesModifierImpl(this, this.updateHelper, eval, refHelper);
395	classPathExtender = new ClassPathExtender(cpMod, ProjectProperties.JAVAC_CLASSPATH, ClassPathSupportCallbackImpl.TAG_WEB_MODULE_LIBRARIES);
396	lookup = createLookup(aux, cpProvider);	390	lookup = createLookup(aux, cpProvider);
397	css = new CopyOnSaveSupport();	391	css = new CopyOnSaveSupport();
398	artifactSupport = new ArtifactCopySupport();	392	artifactSupport = new ArtifactCopySupport();
Lines 569-575 Link Here
569	getTestSourceRoots(), WebProjectProperties.WEB_DOCBASE_DIR),	563	getTestSourceRoots(), WebProjectProperties.WEB_DOCBASE_DIR),
570	new RecommendedTemplatesImpl(this),	564	new RecommendedTemplatesImpl(this),
571	new CoSAwareFileBuiltQueryImpl(QuerySupport.createFileBuiltQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()), this),	565	new CoSAwareFileBuiltQueryImpl(QuerySupport.createFileBuiltQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()), this),
572	classPathExtender,	566	ProjectClassPathModifier.extenderForModifier(cpMod),
573	buildExtender,	567	buildExtender,
574	cpMod,	568	cpMod,
575	new WebProjectOperations(this),	569	new WebProjectOperations(this),

Lines 60-66 Link Here

(-)a/web.struts/src/org/netbeans/modules/web/struts/StrutsFrameworkProvider.java (-7 / +5 lines)
60	import java.util.logging.Level;	60	import java.util.logging.Level;
61	import java.util.logging.Logger;	61	import java.util.logging.Logger;
62	import javax.swing.SwingUtilities;	62	import javax.swing.SwingUtilities;
		63	import org.netbeans.api.java.classpath.ClassPath;
63	import org.netbeans.api.java.project.JavaProjectConstants;	64	import org.netbeans.api.java.project.JavaProjectConstants;
		65	import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
64	import org.netbeans.api.project.ProjectUtils;	66	import org.netbeans.api.project.ProjectUtils;
65	import org.netbeans.api.project.SourceGroup;	67	import org.netbeans.api.project.SourceGroup;
66	import org.netbeans.modules.j2ee.dd.api.common.CreateCapability;	68	import org.netbeans.modules.j2ee.dd.api.common.CreateCapability;
Lines 94-100 Link Here
94		96
95	import org.netbeans.modules.web.struts.ui.StrutsConfigurationPanel;	97	import org.netbeans.modules.web.struts.ui.StrutsConfigurationPanel;
96		98
97	import org.netbeans.spi.java.project.classpath.ProjectClassPathExtender;
98	import org.openide.DialogDescriptor;	99	import org.openide.DialogDescriptor;
99	import org.openide.DialogDisplayer;	100	import org.openide.DialogDisplayer;
100	import org.openide.NotifyDescriptor;	101	import org.openide.NotifyDescriptor;
Lines 129-144 Link Here
129		130
130	Library lib = LibraryManager.getDefault().getLibrary("struts"); //NOI18N	131	Library lib = LibraryManager.getDefault().getLibrary("struts"); //NOI18N
131	if (lib != null) {	132	if (lib != null) {
132	ProjectClassPathExtender cpExtender = (ProjectClassPathExtender) project.getLookup().lookup(ProjectClassPathExtender.class);	133	SourceGroup[] sgs = ProjectUtils.getSources(project).getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
133	if (cpExtender != null) {	134	if (sgs.length > 0) {
134	try {	135	try {
135	cpExtender.addLibrary(lib);	136	ProjectClassPathModifier.addLibraries(new Library[] {lib}, sgs[0].getRootFolder(), ClassPath.COMPILE);
136	} catch (IOException ioe) {	137	} catch (IOException ioe) {
137	Exceptions.printStackTrace(ioe);	138	Exceptions.printStackTrace(ioe);
138	}	139	}
139	} else {
140	Logger.getLogger("global").log(Level.INFO,
141	"WebProjectClassPathExtender not found in the project lookup of project: " + project.getProjectDirectory().getPath()); //NOI18N
142	}	140	}
143		141
144	try {	142	try {

Lines 81-86 Link Here

(-)a/websvc.core/src/org/netbeans/modules/websvc/core/dev/wizard/JaxWsServiceCreator.java (-5 / +4 lines)
81	import javax.lang.model.type.TypeKind;	81	import javax.lang.model.type.TypeKind;
82	import org.netbeans.api.java.classpath.ClassPath;	82	import org.netbeans.api.java.classpath.ClassPath;
83	import org.netbeans.api.java.project.JavaProjectConstants;	83	import org.netbeans.api.java.project.JavaProjectConstants;
		84	import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
84	import org.netbeans.api.java.source.CancellableTask;	85	import org.netbeans.api.java.source.CancellableTask;
85	import org.netbeans.api.java.source.Comment;	86	import org.netbeans.api.java.source.Comment;
86	import org.netbeans.api.java.source.GeneratorUtilities;	87	import org.netbeans.api.java.source.GeneratorUtilities;
Lines 108-114 Link Here
108	import org.netbeans.modules.websvc.api.jaxws.wsdlmodel.WsdlService;	109	import org.netbeans.modules.websvc.api.jaxws.wsdlmodel.WsdlService;
109	import org.netbeans.modules.websvc.core.JaxWsUtils;	110	import org.netbeans.modules.websvc.core.JaxWsUtils;
110	import org.netbeans.modules.websvc.jaxws.api.JAXWSSupport;	111	import org.netbeans.modules.websvc.jaxws.api.JAXWSSupport;
111	import org.netbeans.spi.java.project.classpath.ProjectClassPathExtender;
112	import org.netbeans.spi.project.ui.templates.support.Templates;	112	import org.netbeans.spi.project.ui.templates.support.Templates;
113	import org.openide.DialogDisplayer;	113	import org.openide.DialogDisplayer;
114	import org.openide.ErrorManager;	114	import org.openide.ErrorManager;
Lines 308-324 Link Here
308		308
309	// check if the wsimport class is already present - this means we don't need to add the library	309	// check if the wsimport class is already present - this means we don't need to add the library
310	SourceGroup[] sgs = ProjectUtils.getSources(project).getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);	310	SourceGroup[] sgs = ProjectUtils.getSources(project).getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
		311	if (sgs.length > 0) {
311	ClassPath classPath = ClassPath.getClassPath(sgs[0].getRootFolder(), ClassPath.COMPILE);	312	ClassPath classPath = ClassPath.getClassPath(sgs[0].getRootFolder(), ClassPath.COMPILE);
312	FileObject wsimportFO = classPath.findResource("com/sun/tools/ws/ant/WsImport.class"); // NOI18N	313	FileObject wsimportFO = classPath.findResource("com/sun/tools/ws/ant/WsImport.class"); // NOI18N
313	if (wsimportFO != null) {	314	if (wsimportFO != null) {
314	return;	315	return;
315	}	316	}
316		317
317	ProjectClassPathExtender pce = (ProjectClassPathExtender) project.getLookup().lookup(ProjectClassPathExtender.class);
318	Library jaxws21_ext = LibraryManager.getDefault().getLibrary("jaxws21"); //NOI18N	318	Library jaxws21_ext = LibraryManager.getDefault().getLibrary("jaxws21"); //NOI18N
319	if (pce != null && jaxws21_ext != null) {	319	if (jaxws21_ext != null) {
320	try {	320	try {
321	pce.addLibrary(jaxws21_ext);	321	ProjectClassPathModifier.addLibraries(new Library[] {jaxws21_ext}, sgs[0].getRootFolder(), ClassPath.COMPILE);
322	} catch (IOException e) {	322	} catch (IOException e) {
323	throw new Exception("Unable to add JAXWS 21 Library. " + e.getMessage());	323	throw new Exception("Unable to add JAXWS 21 Library. " + e.getMessage());
324	}	324	}
Lines 327-333 Link Here
327	"ProjectClassPathExtender or library not found");	327	"ProjectClassPathExtender or library not found");
328	}	328	}
329		329
330	if (sgs.length > 0) {
331	try {	330	try {
332	FileObject srcRoot = sgs[0].getRootFolder();	331	FileObject srcRoot = sgs[0].getRootFolder();
333	WSUtils.addJaxWsApiEndorsed(project, srcRoot);	332	WSUtils.addJaxWsApiEndorsed(project, srcRoot);

Lines 58-63 Link Here

(-)a/websvc.jaxrpc/src/org/netbeans/modules/websvc/jaxrpc/client/wizard/JaxRpcClientCreator.java (-5 / +3 lines)
58	import java.util.Set;	58	import java.util.Set;
59	import org.netbeans.api.java.classpath.ClassPath;	59	import org.netbeans.api.java.classpath.ClassPath;
60	import org.netbeans.api.java.project.JavaProjectConstants;	60	import org.netbeans.api.java.project.JavaProjectConstants;
		61	import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
61	import org.netbeans.api.java.queries.UnitTestForSourceQuery;	62	import org.netbeans.api.java.queries.UnitTestForSourceQuery;
62	import org.netbeans.api.progress.ProgressHandle;	63	import org.netbeans.api.progress.ProgressHandle;
63	import org.netbeans.api.progress.ProgressHandleFactory;	64	import org.netbeans.api.progress.ProgressHandleFactory;
Lines 74-81 Link Here
74	import org.netbeans.modules.websvc.api.support.ClientCreator;	75	import org.netbeans.modules.websvc.api.support.ClientCreator;
75	import org.netbeans.modules.websvc.core.ClientWizardProperties;	76	import org.netbeans.modules.websvc.core.ClientWizardProperties;
76	import org.netbeans.modules.websvc.core.WsdlRetriever;	77	import org.netbeans.modules.websvc.core.WsdlRetriever;
77	import org.netbeans.modules.websvc.core.WsdlRetriever;
78	import org.netbeans.spi.java.project.classpath.ProjectClassPathExtender;
79	import org.openide.DialogDisplayer;	78	import org.openide.DialogDisplayer;
80	import org.openide.ErrorManager;	79	import org.openide.ErrorManager;
81	import org.openide.NotifyDescriptor;	80	import org.openide.NotifyDescriptor;
Lines 301-310 Link Here
301	FileObject wscompileFO = classPath.findResource("com/sun/xml/rpc/tools/ant/Wscompile.class");	300	FileObject wscompileFO = classPath.findResource("com/sun/xml/rpc/tools/ant/Wscompile.class");
302	if (wscompileFO==null) {	301	if (wscompileFO==null) {
303	// add jax-rpc16 if webservice is not on classpath	302	// add jax-rpc16 if webservice is not on classpath
304	ProjectClassPathExtender pce = (ProjectClassPathExtender)project.getLookup().lookup(ProjectClassPathExtender.class);
305	Library jaxrpclib = LibraryManager.getDefault().getLibrary("jaxrpc16"); //NOI18N	303	Library jaxrpclib = LibraryManager.getDefault().getLibrary("jaxrpc16"); //NOI18N
306	if ((pce!=null) && (jaxrpclib != null)) {	304	if (jaxrpclib != null) {
307	pce.addLibrary(jaxrpclib);	305	ProjectClassPathModifier.addLibraries(new Library[] {jaxrpclib}, sgs[0].getRootFolder(), ClassPath.COMPILE);
308	}	306	}
309	}	307	}
310		308