public void selectOrderEntry(@NotNull OrderEntry entry) {
for (int row = 0; row < myModel.getRowCount(); row++) {
final OrderEntry orderEntry = getItemAt(row).getEntry();
if (orderEntry != null
&& entry.getPresentableName().equals(orderEntry.getPresentableName())) {
myEntryTable.getSelectionModel().setSelectionInterval(row, row);
TableUtil.scrollSelectionToVisible(myEntryTable);
}
}
IdeFocusManager.getInstance(myState.getProject()).requestFocus(myEntryTable, true);
}
@Nullable
@Override
public OrderEntry findIdeModuleOrderEntry(@NotNull DependencyData data) {
Module ownerIdeModule = findIdeModule(data.getOwnerModule());
if (ownerIdeModule == null) return null;
LibraryDependencyData libraryDependencyData = null;
ModuleDependencyData moduleDependencyData = null;
if (data instanceof LibraryDependencyData) {
libraryDependencyData = (LibraryDependencyData) data;
} else if (data instanceof ModuleDependencyData) {
moduleDependencyData = (ModuleDependencyData) data;
} else {
return null;
}
for (OrderEntry entry : getOrderEntries(ownerIdeModule)) {
if (entry instanceof LibraryOrderEntry && libraryDependencyData != null) {
if (((LibraryOrderEntry) entry).isModuleLevel()
&& libraryDependencyData.getLevel() != LibraryLevel.MODULE) continue;
if (StringUtil.isEmpty(((LibraryOrderEntry) entry).getLibraryName())) {
final Set<String> paths =
ContainerUtil.map2Set(
libraryDependencyData.getTarget().getPaths(LibraryPathType.BINARY),
new Function<String, String>() {
@Override
public String fun(String path) {
return PathUtil.getLocalPath(path);
}
});
final Set<String> entryPaths =
ContainerUtil.map2Set(
entry.getUrls(OrderRootType.CLASSES),
new Function<String, String>() {
@Override
public String fun(String s) {
return PathUtil.getLocalPath(VfsUtilCore.urlToPath(s));
}
});
if (entryPaths.equals(paths) && ((LibraryOrderEntry) entry).getScope() == data.getScope())
return entry;
continue;
}
}
String entryName =
libraryDependencyData != null
? libraryDependencyData.getInternalName()
: moduleDependencyData.getInternalName();
if (entryName.equals(entry.getPresentableName())
&& (!(entry instanceof ExportableOrderEntry)
|| ((ExportableOrderEntry) entry).getScope() == data.getScope())) {
return entry;
}
}
return null;
}
private List<String> collectModuleDepsNames(String moduleName, Class clazz) {
List<String> actual = new ArrayList<String>();
for (OrderEntry e : getRootManager(moduleName).getOrderEntries()) {
if (clazz.isInstance(e)) {
actual.add(e.getPresentableName());
}
}
return actual;
}
private <T> T getModuleDep(String moduleName, String depName, Class<T> clazz) {
T dep = null;
for (OrderEntry e : getRootManager(moduleName).getOrderEntries()) {
if (clazz.isInstance(e) && e.getPresentableName().equals(depName)) {
dep = (T) e;
}
}
assertNotNull(
"Dependency not found: "
+ depName
+ "\namong: "
+ collectModuleDepsNames(moduleName, clazz),
dep);
return dep;
}
private void setupRootAndAnnotateExternally(
@NotNull final OrderEntry entry,
@NotNull final Project project,
@NotNull final PsiModifierListOwner listOwner,
@NotNull final String annotationFQName,
@NotNull final PsiFile fromFile,
@NotNull final String packageName,
@Nullable final PsiNameValuePair[] value) {
final FileChooserDescriptor descriptor =
FileChooserDescriptorFactory.createSingleFolderDescriptor();
descriptor.setTitle(
ProjectBundle.message(
"external.annotations.root.chooser.title", entry.getPresentableName()));
descriptor.setDescription(
ProjectBundle.message("external.annotations.root.chooser.description"));
final VirtualFile newRoot = FileChooser.chooseFile(descriptor, project, null);
if (newRoot == null) {
notifyAfterAnnotationChanging(listOwner, annotationFQName, false);
return;
}
new WriteCommandAction(project) {
@Override
protected void run(final Result result) throws Throwable {
appendChosenAnnotationsRoot(entry, newRoot);
XmlFile xmlFileInRoot =
findXmlFileInRoot(findExternalAnnotationsXmlFiles(listOwner), newRoot);
if (xmlFileInRoot != null) { // file already exists under appeared content root
if (!CodeInsightUtilBase.preparePsiElementForWrite(xmlFileInRoot)) {
notifyAfterAnnotationChanging(listOwner, annotationFQName, false);
return;
}
annotateExternally(listOwner, annotationFQName, xmlFileInRoot, fromFile, value);
} else {
final XmlFile annotationsXml = createAnnotationsXml(newRoot, packageName);
if (annotationsXml != null) {
final List<PsiFile> createdFiles = new ArrayList<PsiFile>();
createdFiles.add(annotationsXml);
String fqn = getFQN(packageName, fromFile);
if (fqn != null) {
myExternalAnnotations.put(fqn, createdFiles);
}
}
annotateExternally(listOwner, annotationFQName, annotationsXml, fromFile, value);
}
}
}.execute();
}
public static void customizeElementLabel(final PsiElement element, final JLabel label) {
if (element != null) {
PsiFile file = element.getContainingFile();
VirtualFile vfile = file == null ? null : file.getVirtualFile();
if (vfile == null) {
label.setText("");
label.setIcon(null);
return;
}
final ProjectFileIndex fileIndex =
ProjectRootManager.getInstance(element.getProject()).getFileIndex();
final Module module = fileIndex.getModuleForFile(vfile);
if (module != null) {
label.setText(module.getName());
label.setIcon(AllIcons.Nodes.Module);
} else {
final List<OrderEntry> entries = fileIndex.getOrderEntriesForFile(vfile);
OrderEntry entry = null;
for (OrderEntry order : entries) {
if (order instanceof LibraryOrderEntry || order instanceof SdkOrderEntry) {
entry = order;
break;
}
}
if (entry != null) {
label.setText(entry.getPresentableName());
label.setIcon(AllIcons.Nodes.PpLibFolder);
}
}
}
}
