| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.netbeans.modules.java.project.ui; |
| |
| import java.beans.PropertyChangeEvent; |
| import java.beans.PropertyChangeListener; |
| import java.io.File; |
| import java.io.IOException; |
| import java.net.URL; |
| import java.util.ArrayDeque; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.EnumSet; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Queue; |
| import java.util.Set; |
| import java.util.concurrent.Callable; |
| import java.util.concurrent.Future; |
| import java.util.concurrent.FutureTask; |
| import java.util.concurrent.RunnableFuture; |
| import java.util.logging.Logger; |
| import javax.swing.Icon; |
| import javax.swing.JButton; |
| import javax.swing.event.ChangeEvent; |
| import javax.swing.event.ChangeListener; |
| import org.netbeans.api.annotations.common.CheckForNull; |
| import org.netbeans.api.annotations.common.NonNull; |
| import org.netbeans.api.annotations.common.NullAllowed; |
| import org.netbeans.api.java.classpath.ClassPath; |
| import org.netbeans.api.java.platform.JavaPlatformManager; |
| import org.netbeans.api.java.queries.SourceLevelQuery; |
| import org.netbeans.api.java.queries.SourceLevelQuery.Profile; |
| import org.netbeans.api.java.source.support.ProfileSupport; |
| import org.netbeans.api.project.FileOwnerQuery; |
| import org.netbeans.api.project.Project; |
| import org.netbeans.api.project.ProjectManager; |
| import org.netbeans.api.project.ProjectUtils; |
| import org.netbeans.api.project.ant.AntArtifact; |
| import org.netbeans.api.project.libraries.Library; |
| import org.netbeans.spi.project.support.ant.AntProjectHelper; |
| import org.netbeans.spi.project.support.ant.PropertyEvaluator; |
| import org.netbeans.spi.project.support.ant.ReferenceHelper; |
| import org.netbeans.spi.project.ui.ProjectProblemsProvider; |
| import org.netbeans.spi.project.ui.support.ProjectProblemsProviderSupport; |
| import org.openide.filesystems.FileUtil; |
| import org.openide.util.Mutex; |
| import org.openide.util.NbBundle; |
| import org.openide.util.Parameters; |
| import org.netbeans.spi.project.support.ant.EditableProperties; |
| import org.netbeans.spi.project.ui.ProjectProblemResolver; |
| import org.openide.DialogDescriptor; |
| import org.openide.DialogDisplayer; |
| import org.openide.util.Exceptions; |
| import org.openide.util.MutexException; |
| |
| import static org.netbeans.modules.java.project.ui.Bundle.*; |
| import org.netbeans.spi.java.classpath.ClassPathFactory; |
| import org.netbeans.spi.java.project.classpath.support.ProjectClassPathSupport; |
| import org.netbeans.spi.project.support.ant.PropertyUtils; |
| import org.openide.filesystems.FileObject; |
| import org.openide.util.ImageUtilities; |
| import org.openide.util.RequestProcessor; |
| import org.openide.util.WeakListeners; |
| /** |
| * |
| * @author Tomas Zezula |
| */ |
| final class ProfileProblemsProviderImpl implements ProjectProblemsProvider, PropertyChangeListener, ChangeListener, Runnable { |
| |
| private static final String LIB_PREFIX = "${libs."; // NOI18N |
| private static final String PRJ_PREFIX = "${reference."; // NOI18N |
| private static final String FILE_PREFIX = "${file.reference."; //NOI18N |
| private static final String REF_PREFIX = "${"; //NOI18N |
| private static final String VOL_CLASSPATH = "classpath"; //NOI18N |
| private static final char PATH_SEPARATOR_CHAR = ':'; //NOI18N |
| private static final String ICON_LIBRARIES = "org/netbeans/modules/java/project/ui/resources/libraries.gif"; //NOI18N |
| private static final String ICON_FILE = "org/netbeans/modules/java/project/ui/resources/jar.gif";//NOI18N |
| private static final int SLIDING_DELAY = 1000; //1s |
| private static final Logger LOG = Logger.getLogger(ProfileProblemsProviderImpl.class.getName()); |
| private static final RequestProcessor RP = new RequestProcessor(ProjectProblemsProviders.class); |
| |
| private final AntProjectHelper antProjectHelper; |
| private final ReferenceHelper referenceHelper; |
| private final PropertyEvaluator evaluator; |
| private final String profileProperty; |
| private final Set<String> classPathProperties; |
| private final ProjectProblemsProviderSupport problemsProviderSupport; |
| //@GuardedBy("foreignSlResults") |
| private final Collection<SourceLevelQuery.Result> foreignSlResults; |
| private final RequestProcessor.Task firer; |
| private final Object listenersInitLock = new Object(); |
| //@GuardedBy("listenersInitLock") |
| private ClassPath classPath; |
| //@GuardedBy("listenersInitLock") |
| private SourceLevelQuery.Result slRes; |
| |
| ProfileProblemsProviderImpl( |
| @NonNull final AntProjectHelper antProjectHelper, |
| @NonNull final ReferenceHelper referenceHelper, |
| @NonNull final PropertyEvaluator evaluator, |
| @NonNull final String profileProperty, |
| @NonNull final String... classPathProperties) { |
| assert antProjectHelper != null; |
| assert referenceHelper != null; |
| assert evaluator != null; |
| assert profileProperty != null; |
| assert classPathProperties != null; |
| this.antProjectHelper = antProjectHelper; |
| this.referenceHelper = referenceHelper; |
| this.evaluator = evaluator; |
| this.profileProperty = profileProperty; |
| this.classPathProperties = new HashSet<String>( |
| Arrays.asList(classPathProperties)); |
| this.problemsProviderSupport = new ProjectProblemsProviderSupport(this); |
| this.foreignSlResults = Collections.synchronizedCollection(new ArrayList<SourceLevelQuery.Result>()); |
| this.firer = RP.create(this); |
| } |
| |
| @Override |
| public void addPropertyChangeListener(@NonNull final PropertyChangeListener listener) { |
| Parameters.notNull("listener", listener); //NOI18N |
| problemsProviderSupport.addPropertyChangeListener(listener); |
| } |
| |
| @Override |
| public void removePropertyChangeListener(@NonNull final PropertyChangeListener listener) { |
| Parameters.notNull("listener", listener); //NOI18N |
| problemsProviderSupport.removePropertyChangeListener(listener); |
| } |
| |
| @Override |
| @NbBundle.Messages({ |
| "LBL_InvalidProfile=Invalid JRE 8 Profile", |
| "DESC_InvalidProfile=The project profile ({0}) is lower than the profile of used libraries ({1}).", |
| "DESC_IllegalProfile=The project libraries have illegal value of profile." |
| }) |
| public Collection<? extends ProjectProblem> getProblems() { |
| return problemsProviderSupport.getProblems(new ProjectProblemsProviderSupport.ProblemsCollector() { |
| @Override |
| public Collection<? extends ProjectProblem> collectProblems() { |
| return ProjectManager.mutex().readAccess(new Mutex.Action<Collection<? extends ProjectProblem>>() { |
| @Override |
| public Collection<? extends ProjectProblem> run() { |
| final SourceLevelQuery.Result mySL = listenenOnProjectMetadata(); |
| final Profile profile = mySL.getProfile(); |
| if (profile == Profile.DEFAULT) { |
| return Collections.<ProjectProblem>emptySet(); |
| } |
| final Set<Reference> problems = collectReferencesWithWrongProfile(profile); |
| if (problems.isEmpty()) { |
| return Collections.<ProjectProblem>emptySet(); |
| } |
| Profile minProfile = null; |
| for (Reference problem : problems) { |
| final Profile problemProfile = problem.getRequiredProfile(); |
| minProfile = max(minProfile, problemProfile); |
| } |
| return Collections.<ProjectProblem>singleton( |
| ProjectProblem.createError( |
| LBL_InvalidProfile(), |
| minProfile != null |
| ? DESC_InvalidProfile(profile.getDisplayName(), minProfile.getDisplayName()) |
| : DESC_IllegalProfile(), |
| new ProfileResolver( |
| antProjectHelper, |
| profileProperty, |
| profile, |
| problems))); |
| } |
| }); |
| } |
| }); |
| } |
| |
| @Override |
| public void propertyChange(@NonNull final PropertyChangeEvent event) { |
| final String propName = event.getPropertyName(); |
| if (ClassPath.PROP_ROOTS.equals(propName) || |
| JavaPlatformManager.PROP_INSTALLED_PLATFORMS.equals(propName)) { |
| firer.schedule(SLIDING_DELAY); |
| } |
| } |
| |
| @Override |
| public void stateChanged(ChangeEvent ce) { |
| firer.schedule(SLIDING_DELAY); |
| } |
| |
| @Override |
| public void run() { |
| problemsProviderSupport.fireProblemsChange(); |
| } |
| |
| private SourceLevelQuery.Result listenenOnProjectMetadata() { |
| synchronized (listenersInitLock) { |
| if (slRes == null) { |
| assert classPath == null; |
| final JavaPlatformManager jpm = JavaPlatformManager.getDefault(); |
| jpm.addPropertyChangeListener(WeakListeners.propertyChange(this, jpm)); |
| slRes = SourceLevelQuery.getSourceLevel2(antProjectHelper.getProjectDirectory()); |
| slRes.addChangeListener(this); |
| final File baseFolder = FileUtil.toFile(antProjectHelper.getProjectDirectory()); |
| if (baseFolder != null) { |
| final ClassPath cp = ClassPathFactory.createClassPath(ProjectClassPathSupport.createPropertyBasedClassPathImplementation( |
| baseFolder, |
| evaluator, |
| classPathProperties.toArray(new String[classPathProperties.size()]))); |
| cp.addPropertyChangeListener(this); |
| cp.getRoots(); |
| classPath = cp; |
| } |
| } |
| return slRes; |
| } |
| } |
| |
| @NonNull |
| private Set<Reference> collectReferencesWithWrongProfile(@NonNull final Profile currentProfile) { |
| assert ProjectManager.mutex().isReadAccess() || ProjectManager.mutex().isWriteAccess(); |
| final Set<Reference> res = new HashSet<Reference>(); |
| final EditableProperties projectProps = antProjectHelper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH); |
| final EditableProperties privateProps = antProjectHelper.getProperties(AntProjectHelper.PRIVATE_PROPERTIES_PATH); |
| final EditableProperties globalProps = PropertyUtils.getGlobalProperties(); |
| final Collection<SourceLevelQuery.Result> newSlResults = new ArrayDeque<SourceLevelQuery.Result>(); |
| for (String cpId : classPathProperties) { |
| collectReferencesWithWrongProfileImpl( |
| cpId, |
| currentProfile, |
| antProjectHelper, |
| evaluator, |
| referenceHelper, |
| projectProps, |
| privateProps, |
| globalProps, |
| res, |
| newSlResults); |
| } |
| synchronized (foreignSlResults) { |
| for (final Iterator<? extends SourceLevelQuery.Result> it = foreignSlResults.iterator(); it.hasNext();) { |
| final SourceLevelQuery.Result cslr = it.next(); |
| it.remove(); |
| cslr.removeChangeListener(this); |
| } |
| assert foreignSlResults.isEmpty(); |
| for (SourceLevelQuery.Result cslr : newSlResults) { |
| cslr.addChangeListener(this); |
| foreignSlResults.add(cslr); |
| } |
| } |
| return res; |
| } |
| |
| private static void collectReferencesWithWrongProfileImpl( |
| @NonNull final String classPathId, |
| @NonNull final Profile requiredProfile, |
| @NonNull final AntProjectHelper antProjectHelper, |
| @NonNull final PropertyEvaluator eval, |
| @NonNull final ReferenceHelper refHelper, |
| @NonNull final EditableProperties projectProps, |
| @NonNull final EditableProperties privateProps, |
| @NonNull final EditableProperties globalProps, |
| @NonNull final Set<? super Reference> collector, |
| @NonNull final Collection<? super SourceLevelQuery.Result> slResCollector) { |
| String cp = projectProps.getProperty(classPathId); |
| if (cp == null) { |
| cp = privateProps.getProperty(classPathId); |
| } |
| if (cp == null) { |
| cp = globalProps.getProperty(classPathId); |
| } |
| if (cp != null) { |
| final Queue<String> todo = new ArrayDeque<String>(Arrays.asList(PropertyUtils.tokenizePath(cp))); |
| while (!todo.isEmpty()) { |
| final String rawEntry = todo.remove(); |
| final String propName = getAntPropertyName(rawEntry); |
| if (propName == null) { |
| continue; |
| } |
| if (rawEntry.startsWith(LIB_PREFIX)) { |
| final String libName = rawEntry.substring(LIB_PREFIX.length(),rawEntry.lastIndexOf('.')); |
| final Library lib = refHelper.findLibrary(libName); |
| if (lib != null) { |
| final Collection<? extends ProfileSupport.Violation> res = |
| ProfileSupport.findProfileViolations( |
| requiredProfile, |
| Collections.<URL>emptySet(), |
| lib.getContent(VOL_CLASSPATH), |
| Collections.<URL>emptySet(), |
| EnumSet.of(ProfileSupport.Validation.BINARIES_BY_MANIFEST)); |
| if (!res.isEmpty()) { |
| final Profile maxProfile = findMaxProfile(res); |
| collector.add(new LibraryReference(classPathId, rawEntry, maxProfile, lib)); |
| } |
| } |
| } else if (rawEntry.startsWith(PRJ_PREFIX)) { |
| final Object[] ref = refHelper.findArtifactAndLocation(rawEntry); |
| if (ref[0] != null) { |
| AntArtifact artifact = (AntArtifact)ref[0]; |
| final SourceLevelQuery.Result slRes = SourceLevelQuery.getSourceLevel2(artifact.getProject().getProjectDirectory()); |
| slResCollector.add(slRes); |
| final Profile minProfile = slRes.getProfile(); |
| if (isBroken(requiredProfile, minProfile)) { |
| collector.add(new ProjectReference(classPathId, rawEntry, minProfile, artifact.getProject())); |
| } |
| } |
| |
| } else if (rawEntry.startsWith(FILE_PREFIX)) { |
| final String path = eval.getProperty(propName); |
| if (path != null) { |
| final File file = antProjectHelper.resolveFile(path); |
| final URL root = FileUtil.urlForArchiveOrDir(file); |
| if (root != null) { |
| final Collection<? extends ProfileSupport.Violation> res = |
| ProfileSupport.findProfileViolations( |
| requiredProfile, |
| Collections.<URL>emptySet(), |
| Collections.singleton(root), |
| Collections.<URL>emptySet(), |
| EnumSet.of(ProfileSupport.Validation.BINARIES_BY_MANIFEST)); |
| if (!res.isEmpty()) { |
| final Profile maxProfile = findMaxProfile(res); |
| collector.add(new FileReference(classPathId, rawEntry, maxProfile, file)); |
| } |
| } |
| } |
| } else if (rawEntry.startsWith(REF_PREFIX)) { |
| collectReferencesWithWrongProfileImpl( |
| propName, |
| requiredProfile, |
| antProjectHelper, |
| eval, |
| refHelper, |
| projectProps, |
| privateProps, |
| globalProps, |
| collector, |
| slResCollector); |
| } else { |
| final File file = antProjectHelper.resolveFile(propName); |
| final URL root = FileUtil.urlForArchiveOrDir(file); |
| if (root != null) { |
| final Collection<? extends ProfileSupport.Violation> res = |
| ProfileSupport.findProfileViolations( |
| requiredProfile, |
| Collections.<URL>emptySet(), |
| Collections.singleton(root), |
| Collections.<URL>emptySet(), |
| EnumSet.of(ProfileSupport.Validation.BINARIES_BY_MANIFEST)); |
| if (!res.isEmpty()) { |
| final Profile maxProfile = findMaxProfile(res); |
| collector.add(new FileReference(classPathId, rawEntry, maxProfile, file)); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| private static boolean isBroken( |
| @NonNull final Profile requiredProfile, |
| @NullAllowed final Profile profile) { |
| if (profile == null) { |
| return true; |
| } |
| final Profile max = max(requiredProfile, profile); |
| return !max.equals(Profile.DEFAULT) && |
| !max.equals(requiredProfile); |
| } |
| |
| @CheckForNull |
| private static String getAntPropertyName(@NullAllowed String reference) { |
| if (reference != null |
| && reference.startsWith("${") // NOI18N |
| && reference.endsWith("}")) { // NOI18N |
| reference = reference.substring(2, reference.length() - 1); |
| } |
| return reference; |
| } |
| |
| @CheckForNull |
| private static Profile findMaxProfile(@NonNull final Iterable<? extends ProfileSupport.Violation> violations) { |
| Profile current = null; |
| for (ProfileSupport.Violation violation : violations) { |
| Profile p = violation.getRequiredProfile(); |
| if (p == null) { |
| //Broken profile - no need to continue |
| return null; |
| } |
| current = max(current, p); |
| } |
| return current; |
| } |
| |
| @CheckForNull |
| static Profile max (@NullAllowed Profile a, @NullAllowed Profile b) { |
| if (b == null) { |
| return a; |
| } |
| if (a == null) { |
| return b; |
| } |
| return a.compareTo(b) <= 0 ? |
| b : |
| a; |
| } |
| |
| @NonNull |
| static Profile requiredProfile( |
| @NonNull final Collection<? extends Reference> state, |
| @NonNull Profile initial) { |
| Profile current = initial; |
| for (ProfileProblemsProviderImpl.Reference re : state) { |
| current = max(current, re.getRequiredProfile()); |
| } |
| return current; |
| } |
| |
| abstract static class Reference { |
| |
| private final String classPathId; |
| private final String rawId; |
| private final Profile requiredProfile; |
| |
| private Reference( |
| @NonNull final String classPathId, |
| @NonNull final String rawId, |
| @NullAllowed final Profile requiredProfile) { |
| Parameters.notNull("classPathId", classPathId); //NOI18N |
| Parameters.notNull("rawId", rawId); //NOI18N |
| this.classPathId = classPathId; |
| this.rawId = rawId; |
| this.requiredProfile = requiredProfile; |
| } |
| |
| @NonNull |
| abstract String getDisplayName(); |
| |
| @NonNull |
| abstract String getToolTipText(); |
| |
| @NonNull |
| abstract Icon getIcon(); |
| |
| @CheckForNull |
| final Profile getRequiredProfile() { |
| return requiredProfile; |
| } |
| |
| private void remove(@NonNull final AntProjectHelper helper) { |
| final EditableProperties props = helper.getProperties (AntProjectHelper.PROJECT_PROPERTIES_PATH); |
| String rawPath = props.getProperty (classPathId); |
| if (rawPath != null) { |
| final String[] pathElements = PropertyUtils.tokenizePath(rawPath); |
| final List<String> result = new ArrayList<String>(pathElements.length); |
| boolean changed = false; |
| for (String pathElement : pathElements) { |
| if (rawId.equals(pathElement)) { |
| changed = true; |
| continue; |
| } |
| result.add(pathElement + PATH_SEPARATOR_CHAR); |
| } |
| if (!result.isEmpty()) { |
| final String last = result.get(result.size()-1); |
| result.set(result.size()-1, last.substring(0, last.length()-1)); |
| } |
| if (changed) { |
| props.setProperty(classPathId, result.toArray(new String[result.size()])); |
| helper.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, props); |
| } |
| } |
| } |
| |
| @Override |
| public int hashCode() { |
| int hash = 17; |
| hash = 31 * hash + this.classPathId.hashCode(); |
| hash = 31 * hash + this.rawId.hashCode(); |
| return hash; |
| } |
| |
| @Override |
| public boolean equals(Object other) { |
| if (other == this) { |
| return true; |
| } |
| if (!(other instanceof Reference)) { |
| return false; |
| } |
| final Reference otherRef = (Reference) other; |
| return classPathId.equals(otherRef.classPathId) && |
| rawId.equals(otherRef.rawId); |
| } |
| |
| |
| } |
| |
| private static final class LibraryReference extends Reference { |
| |
| private final Library lib; |
| |
| private LibraryReference( |
| @NonNull final String classPathId, |
| @NonNull final String rawId, |
| @NullAllowed final Profile requiredProfile, |
| @NonNull final Library lib) { |
| super(classPathId, rawId, requiredProfile); |
| Parameters.notNull("lib", lib); //NOI18N |
| this.lib = lib; |
| } |
| |
| @Override |
| String getDisplayName() { |
| return this.lib.getDisplayName(); |
| } |
| |
| @Override |
| String getToolTipText() { |
| return lib.getDisplayName(); |
| } |
| |
| @Override |
| Icon getIcon() { |
| return ImageUtilities.loadImageIcon(ICON_LIBRARIES, false); |
| } |
| } |
| |
| private static final class ProjectReference extends Reference { |
| private final Project prj; |
| |
| private ProjectReference( |
| @NonNull final String classPathId, |
| @NonNull final String rawId, |
| @NullAllowed final Profile requiredProfile, |
| @NonNull final Project prj) { |
| super(classPathId, rawId, requiredProfile); |
| Parameters.notNull("prj", prj); //NOI18N |
| this.prj = prj; |
| } |
| |
| @Override |
| String getDisplayName() { |
| return ProjectUtils.getInformation(prj).getDisplayName(); |
| } |
| |
| @Override |
| String getToolTipText() { |
| return FileUtil.getFileDisplayName(prj.getProjectDirectory()); |
| } |
| |
| @Override |
| Icon getIcon() { |
| return ProjectUtils.getInformation(prj).getIcon(); |
| } |
| } |
| |
| private static final class FileReference extends Reference { |
| |
| private final File file; |
| |
| private FileReference( |
| @NonNull final String classPathId, |
| @NonNull final String rawId, |
| @NullAllowed final Profile requiredProfile, |
| @NonNull final File file) { |
| super(classPathId, rawId, requiredProfile); |
| Parameters.notNull("file", file); //NOI18N |
| this.file = file; |
| } |
| |
| @Override |
| String getDisplayName() { |
| return file.getName(); |
| } |
| |
| @Override |
| String getToolTipText() { |
| return file.getAbsolutePath(); |
| } |
| |
| @Override |
| Icon getIcon() { |
| return ImageUtilities.loadImageIcon(ICON_FILE, false); |
| } |
| } |
| |
| private static final class ProfileResolver implements ProjectProblemResolver { |
| |
| private final AntProjectHelper antProjectHelper; |
| private final String profileProperty; |
| private final Profile currentProfile; |
| private final Collection<? extends Reference> state; |
| |
| private ProfileResolver( |
| @NonNull final AntProjectHelper antProjectHelper, |
| @NonNull final String profileProperty, |
| @NonNull final Profile currentProfile, |
| @NonNull final Collection<? extends Reference> state) { |
| assert antProjectHelper != null; |
| assert profileProperty != null; |
| assert currentProfile != null; |
| assert state != null; |
| this.antProjectHelper = antProjectHelper; |
| this.profileProperty = profileProperty; |
| this.currentProfile = currentProfile; |
| this.state = state; |
| } |
| |
| @Override |
| @NbBundle.Messages({ |
| "LBL_ResolveProfile=Resolve Invalid Project Profile", |
| "LBL_ResolveButton=OK", |
| "AN_ResolveButton=Resolve", |
| "AD_ResolveButton=Resolve the profile problems" |
| }) |
| public Future<Result> resolve() { |
| final JButton ok = new JButton(LBL_ResolveButton()); |
| ok.getAccessibleContext().setAccessibleName(AN_ResolveButton()); |
| ok.getAccessibleContext().setAccessibleDescription(AD_ResolveButton()); |
| final FixProfile panel = new FixProfile(ok, currentProfile, state); |
| final DialogDescriptor dd = new DialogDescriptor( |
| panel, |
| LBL_ResolveProfile(), |
| true, |
| new Object[]{ |
| ok, |
| DialogDescriptor.CANCEL_OPTION |
| }, |
| ok, |
| DialogDescriptor.DEFAULT_ALIGN, |
| null, |
| null); |
| if (DialogDisplayer.getDefault().notify(dd) == ok) { |
| return RP.submit(new Callable<ProjectProblemsProvider.Result>() { |
| @Override |
| public ProjectProblemsProvider.Result call() throws Exception { |
| ProjectProblemsProvider.Status status = ProjectProblemsProvider.Status.UNRESOLVED; |
| try { |
| ProjectManager.mutex().writeAccess(new Mutex.ExceptionAction<Void>() { |
| @Override |
| public Void run() throws IOException { |
| final boolean shouldUpdate = panel.shouldUpdateProfile(); |
| if (shouldUpdate) { |
| final Profile newProfile = panel.getProfile(); |
| final EditableProperties props = antProjectHelper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH); |
| if (newProfile == null || |
| newProfile == Profile.DEFAULT) { |
| props.remove(profileProperty); |
| } else { |
| props.put(profileProperty, newProfile.getName()); |
| } |
| antProjectHelper.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, props); |
| } |
| for (Reference rootToRemove : panel.getRootsToRemove()) { |
| rootToRemove.remove(antProjectHelper); |
| } |
| ProjectManager.getDefault().saveProject( |
| FileOwnerQuery.getOwner(antProjectHelper.getProjectDirectory())); |
| return null; |
| } |
| }); |
| status = ProjectProblemsProvider.Status.RESOLVED; |
| } catch (MutexException e) { |
| Exceptions.printStackTrace(e); |
| } |
| return ProjectProblemsProvider.Result.create(status); |
| } |
| }); |
| } |
| final RunnableFuture<Result> res = new FutureTask<Result>( |
| new Callable<Result>() { |
| @Override |
| public Result call() { |
| return ProjectProblemsProvider.Result.create(ProjectProblemsProvider.Status.UNRESOLVED); |
| } |
| }); |
| res.run(); |
| return res; |
| } |
| |
| @Override |
| public int hashCode() { |
| int res = 17; |
| final FileObject projDir = antProjectHelper.getProjectDirectory(); |
| res = res * 31 + (projDir == null ? 0 : projDir.toURI().hashCode()); |
| res = res * 31 + currentProfile.hashCode(); |
| return res; |
| } |
| |
| @Override |
| public boolean equals(@NullAllowed Object other) { |
| if (other == this) { |
| return true; |
| } |
| if (!(other instanceof ProfileResolver)) { |
| return false; |
| } |
| final ProfileResolver otherResolver = (ProfileResolver) other; |
| final FileObject projDir = antProjectHelper.getProjectDirectory(); |
| final FileObject otherProjDir = otherResolver.antProjectHelper.getProjectDirectory(); |
| return |
| currentProfile.equals(otherResolver.currentProfile) && |
| (projDir == null ? otherProjDir == null : projDir.equals(otherProjDir)); |
| } |
| } |
| } |
