private boolean checkReadonlyUsages() {
final Set<VirtualFile> readOnlyUsages = getReadOnlyUsagesFiles();
return readOnlyUsages.isEmpty()
|| !ReadonlyStatusHandler.getInstance(myProject)
.ensureFilesWritable(VfsUtil.toVirtualFileArray(readOnlyUsages))
.hasReadonlyFiles();
}
@NotNull
private Set<Usage> getReadOnlyUsages() {
final Set<Usage> result = new THashSet<Usage>();
final Set<Map.Entry<Usage, UsageNode>> usages = myUsageNodes.entrySet();
for (Map.Entry<Usage, UsageNode> entry : usages) {
Usage usage = entry.getKey();
UsageNode node = entry.getValue();
if (node != null && node != NULL_NODE && !node.isExcluded() && usage.isReadOnly()) {
result.add(usage);
}
}
return result;
}
@Override
@NotNull
public Set<Usage> getExcludedUsages() {
Set<Usage> result = new THashSet<Usage>();
for (Map.Entry<Usage, UsageNode> entry : myUsageNodes.entrySet()) {
UsageNode node = entry.getValue();
Usage usage = entry.getKey();
if (node == NULL_NODE || node == null) {
continue;
}
if (node.isExcluded()) {
result.add(usage);
}
}
return result;
}
private InspectionProfile guessProfileToSelect(
final InspectionProjectProfileManager profileManager) {
final Set<InspectionProfile> profiles = new HashSet<InspectionProfile>();
final RefEntity[] selectedElements = myTree.getSelectedElements();
for (RefEntity selectedElement : selectedElements) {
if (selectedElement instanceof RefElement) {
final RefElement refElement = (RefElement) selectedElement;
final PsiElement element = refElement.getElement();
if (element != null) {
profiles.add(profileManager.getInspectionProfile());
}
}
}
if (profiles.isEmpty()) {
return (InspectionProfile) profileManager.getProjectProfileImpl();
}
return profiles.iterator().next();
}
@Nullable
private UsageTarget[] getSelectedUsageTargets() {
TreePath[] selectionPaths = myTree.getSelectionPaths();
if (selectionPaths == null) return null;
Set<UsageTarget> targets = new THashSet<UsageTarget>();
for (TreePath selectionPath : selectionPaths) {
Object lastPathComponent = selectionPath.getLastPathComponent();
if (lastPathComponent instanceof UsageTargetNode) {
UsageTargetNode usageTargetNode = (UsageTargetNode) lastPathComponent;
UsageTarget target = usageTargetNode.getTarget();
if (target != null && target.isValid()) {
targets.add(target);
}
}
}
return targets.isEmpty() ? null : targets.toArray(new UsageTarget[targets.size()]);
}
private void rulesChanged() {
ApplicationManager.getApplication().assertIsDispatchThread();
final ArrayList<UsageState> states = new ArrayList<UsageState>();
captureUsagesExpandState(new TreePath(myTree.getModel().getRoot()), states);
final List<Usage> allUsages = new ArrayList<Usage>(myUsageNodes.keySet());
Collections.sort(allUsages, USAGE_COMPARATOR);
final Set<Usage> excludedUsages = getExcludedUsages();
reset();
myBuilder.setGroupingRules(getActiveGroupingRules(myProject));
myBuilder.setFilteringRules(getActiveFilteringRules(myProject));
ApplicationManager.getApplication()
.runReadAction(
new Runnable() {
@Override
public void run() {
for (Usage usage : allUsages) {
if (!usage.isValid()) {
continue;
}
if (usage instanceof MergeableUsage) {
((MergeableUsage) usage).reset();
}
appendUsage(usage);
}
}
});
excludeUsages(excludedUsages.toArray(new Usage[excludedUsages.size()]));
if (myCentralPanel != null) {
setupCentralPanel();
}
SwingUtilities.invokeLater(
new Runnable() {
@Override
public void run() {
if (isDisposed) return;
restoreUsageExpandState(states);
updateImmediately();
}
});
}
private static void collectUsages(
@NotNull DefaultMutableTreeNode node, @NotNull Set<Usage> usages) {
if (node instanceof UsageNode) {
UsageNode usageNode = (UsageNode) node;
final Usage usage = usageNode.getUsage();
usages.add(usage);
}
Enumeration enumeration = node.children();
while (enumeration.hasMoreElements()) {
DefaultMutableTreeNode child = (DefaultMutableTreeNode) enumeration.nextElement();
collectUsages(child, usages);
}
}
@NotNull
private Set<VirtualFile> getReadOnlyUsagesFiles() {
Set<Usage> usages = getReadOnlyUsages();
Set<VirtualFile> result = new THashSet<VirtualFile>();
for (Usage usage : usages) {
if (usage instanceof UsageInFile) {
UsageInFile usageInFile = (UsageInFile) usage;
VirtualFile file = usageInFile.getFile();
if (file != null) result.add(file);
}
if (usage instanceof UsageInFiles) {
UsageInFiles usageInFiles = (UsageInFiles) usage;
ContainerUtil.addAll(result, usageInFiles.getFiles());
}
}
for (UsageTarget target : myTargets) {
VirtualFile[] files = target.getFiles();
if (files == null) continue;
ContainerUtil.addAll(result, files);
}
return result;
}
@Override
public void calcData(final DataKey key, final DataSink sink) {
Node node = getSelectedNode();
if (key == PlatformDataKeys.PROJECT) {
sink.put(PlatformDataKeys.PROJECT, myProject);
} else if (key == USAGE_VIEW_KEY) {
sink.put(USAGE_VIEW_KEY, UsageViewImpl.this);
} else if (key == PlatformDataKeys.NAVIGATABLE_ARRAY) {
sink.put(PlatformDataKeys.NAVIGATABLE_ARRAY, getNavigatablesForNodes(getSelectedNodes()));
} else if (key == PlatformDataKeys.EXPORTER_TO_TEXT_FILE) {
sink.put(PlatformDataKeys.EXPORTER_TO_TEXT_FILE, myTextFileExporter);
} else if (key == USAGES_KEY) {
final Set<Usage> selectedUsages = getSelectedUsages();
sink.put(
USAGES_KEY,
selectedUsages != null
? selectedUsages.toArray(new Usage[selectedUsages.size()])
: null);
} else if (key == USAGE_TARGETS_KEY) {
sink.put(USAGE_TARGETS_KEY, getSelectedUsageTargets());
} else if (key == PlatformDataKeys.VIRTUAL_FILE_ARRAY) {
final Set<Usage> usages = getSelectedUsages();
Usage[] ua = usages != null ? usages.toArray(new Usage[usages.size()]) : null;
VirtualFile[] data = UsageDataUtil.provideVirtualFileArray(ua, getSelectedUsageTargets());
sink.put(PlatformDataKeys.VIRTUAL_FILE_ARRAY, data);
} else if (key == PlatformDataKeys.HELP_ID) {
sink.put(PlatformDataKeys.HELP_ID, HELP_ID);
} else if (key == PlatformDataKeys.COPY_PROVIDER) {
sink.put(PlatformDataKeys.COPY_PROVIDER, this);
} else if (node != null) {
Object userObject = node.getUserObject();
if (userObject instanceof TypeSafeDataProvider) {
((TypeSafeDataProvider) userObject).calcData(key, sink);
} else if (userObject instanceof DataProvider) {
DataProvider dataProvider = (DataProvider) userObject;
Object data = dataProvider.getData(key.getName());
if (data != null) {
sink.put(key, data);
}
}
}
}
