IDEA-59460: Add menu entry for opening library settings on libraries in project view

2026-09-27 10:03:11 +07:00 · 2011-08-11 13:51:36 +04:00
parent 1037f64ac2
commit 1c3c28fb00
16 changed files with 142 additions and 96 deletions
@@ -16,7 +16,6 @@
 package com.intellij.openapi.roots.ui.configuration;

 import com.intellij.ide.projectView.impl.ModuleGroup;
-import com.intellij.ide.projectView.impl.nodes.NamedLibraryElement;
 import com.intellij.ide.util.projectWizard.JdkChooserPanel;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.options.ShowSettingsUtil;
@@ -85,21 +84,20 @@ public class IdeaProjectSettingsService extends ProjectSettingsService {
    ShowSettingsUtil.getInstance().editConfigurable(myProject, ProjectStructureConfigurable.getInstance(myProject), new Runnable() {
      @Override
      public void run() {
-        ModuleStructureConfigurable.getInstance(myProject).selectOrderEntry(module, orderEntry);
+        ProjectStructureConfigurable.getInstance(myProject).selectOrderEntry(module, orderEntry);
      }
    });
  }

  @Override
-  public boolean canOpenProjectLibrarySettings(NamedLibraryElement value) {
+  public boolean canOpenLibraryOrSdkSettings(OrderEntry orderEntry) {
    return true;
  }

-  public void openProjectLibrarySettings(final NamedLibraryElement element) {
+  public void openLibraryOrSdkSettings(@NotNull final OrderEntry orderEntry) {
    final ProjectStructureConfigurable config = ProjectStructureConfigurable.getInstance(myProject);
    ShowSettingsUtil.getInstance().editConfigurable(myProject, config, new Runnable() {
      public void run() {
-        final OrderEntry orderEntry = element.getOrderEntry();
        if (orderEntry instanceof JdkOrderEntry) {
          config.select(((JdkOrderEntry)orderEntry).getJdk(), true);
        } else {
@@ -20,6 +20,7 @@ import com.intellij.ide.util.PropertiesComponent;
 import com.intellij.openapi.actionSystem.*;
 import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.module.Module;
+import com.intellij.openapi.module.ModuleConfigurationEditor;
 import com.intellij.openapi.module.ModuleManager;
 import com.intellij.openapi.options.BaseConfigurable;
 import com.intellij.openapi.options.Configurable;
@@ -30,6 +31,7 @@ import com.intellij.openapi.project.ProjectBundle;
 import com.intellij.openapi.project.ProjectManager;
 import com.intellij.openapi.projectRoots.Sdk;
 import com.intellij.openapi.roots.LibraryOrderEntry;
+import com.intellij.openapi.roots.OrderEntry;
 import com.intellij.openapi.roots.libraries.Library;
 import com.intellij.openapi.roots.libraries.LibraryTablesRegistrar;
 import com.intellij.openapi.roots.ui.configuration.artifacts.ArtifactsStructureConfigurable;
@@ -420,15 +422,32 @@ public class ProjectStructureConfigurable extends BaseConfigurable implements Se
  public ActionCallback select(@NotNull LibraryOrderEntry libraryOrderEntry, final boolean requestFocus) {
    final Library lib = libraryOrderEntry.getLibrary();
    if (lib == null || lib.getTable() == null) {
-      Place place = createPlaceFor(myModulesConfig);
-      place.putPath(BaseStructureConfigurable.TREE_OBJECT, libraryOrderEntry.getOwnerModule());
-      return navigateTo(place, requestFocus);
+      return selectOrderEntry(libraryOrderEntry.getOwnerModule(), libraryOrderEntry);
    }
    Place place = createPlaceFor(getConfigurableFor(lib));
    place.putPath(BaseStructureConfigurable.TREE_NAME, libraryOrderEntry.getLibraryName());
    return navigateTo(place, requestFocus);
  }

+  public ActionCallback selectOrderEntry(@NotNull final Module module, @Nullable final OrderEntry orderEntry) {
+    return select(module.getName(), null, true).doWhenDone(new Runnable() {
+      public void run() {
+        final MasterDetailsComponent.MyNode node = ModuleStructureConfigurable.getInstance(myProject).findModuleNode(module);
+        if (node != null) {
+          ModuleConfigurable moduleConfigurable = (ModuleConfigurable)node.getConfigurable();
+          ModuleEditor moduleEditor = moduleConfigurable.getModuleEditor();
+          moduleEditor.setSelectedTabName(ClasspathEditor.NAME);
+          if (orderEntry != null) {
+            ModuleConfigurationEditor editor = moduleEditor.getEditor(ClasspathEditor.NAME);
+            if (editor instanceof ClasspathEditor) {
+              ((ClasspathEditor)editor).selectOrderEntry(orderEntry);
+            }
+          }
+        }
+      }
+    });
+  }
+
  public ActionCallback navigateTo(@Nullable final Place place, final boolean requestFocus) {
    final Configurable toSelect = (Configurable)place.getPath(CATEGORY);

@@ -30,7 +30,6 @@ import com.intellij.openapi.roots.ui.configuration.ChooseModulesDialog;
 import com.intellij.openapi.roots.ui.configuration.FacetsProvider;
 import com.intellij.openapi.roots.ui.configuration.ModulesProvider;
 import com.intellij.openapi.roots.ui.configuration.ProjectStructureConfigurable;
-import com.intellij.openapi.roots.ui.configuration.projectRoot.ModuleStructureConfigurable;
 import com.intellij.packaging.artifacts.Artifact;
 import com.intellij.packaging.artifacts.ArtifactModel;
 import com.intellij.packaging.artifacts.ArtifactType;
@@ -124,7 +123,7 @@ public class ArtifactEditorContextImpl implements ArtifactEditorContext {
            final ModuleLibraryOrderEntryImpl libraryEntry = (ModuleLibraryOrderEntryImpl)entry;
            if (libraryName != null && libraryName.equals(libraryEntry.getLibraryName())
               || libraryName == null && library.equals(libraryEntry.getLibrary())) {
-              ModuleStructureConfigurable.getInstance(getProject()).selectOrderEntry(module, libraryEntry);
+              ProjectStructureConfigurable.getInstance(getProject()).selectOrderEntry(module, libraryEntry);
              return;
            }
          }
@@ -26,7 +26,7 @@ import com.intellij.openapi.roots.ModuleRootEvent;
 import com.intellij.openapi.roots.ModuleRootListener;
 import com.intellij.openapi.roots.ModuleSourceOrderEntry;
 import com.intellij.openapi.roots.OrderEntry;
-import com.intellij.openapi.roots.ui.configuration.projectRoot.ModuleStructureConfigurable;
+import com.intellij.openapi.roots.ui.configuration.ProjectStructureConfigurable;
 import com.intellij.openapi.roots.ui.util.CellAppearance;
 import com.intellij.openapi.roots.ui.util.OrderEntryCellAppearanceUtils;
 import com.intellij.openapi.ui.MasterDetailsComponent;
@@ -39,8 +39,8 @@ import com.intellij.ui.PopupHandler;
 import com.intellij.ui.SimpleColoredComponent;
 import com.intellij.ui.SimpleTextAttributes;
 import com.intellij.ui.components.JBScrollPane;
-import com.intellij.util.PathUtil;
 import com.intellij.ui.treeStructure.Tree;
+import com.intellij.util.PathUtil;
 import com.intellij.util.messages.MessageBusConnection;
 import com.intellij.util.ui.UIUtil;
 import com.intellij.util.ui.tree.TreeUtil;
@@ -269,13 +269,12 @@ public class AnalyzeDependenciesComponent extends MasterDetailsComponent {
      if (module == null) {
        return;
      }
-      ModuleStructureConfigurable c = ModuleStructureConfigurable.getInstance(module.getProject());
      final ModuleDependenciesAnalyzer.OrderPathElement element = e.getData(ORDER_PATH_ELEMENT_KEY);
      if (element != null && element instanceof ModuleDependenciesAnalyzer.OrderEntryPathElement) {
        final ModuleDependenciesAnalyzer.OrderEntryPathElement o = (ModuleDependenciesAnalyzer.OrderEntryPathElement)element;
        final OrderEntry entry = o.entry();
        final Module m = entry.getOwnerModule();
-        c.selectOrderEntry(m, entry);
+        ProjectStructureConfigurable.getInstance(module.getProject()).selectOrderEntry(m, entry);
      }
    }
  }
@@ -20,7 +20,7 @@ import com.intellij.openapi.module.Module;
 import com.intellij.openapi.roots.LibraryOrderEntry;
 import com.intellij.openapi.roots.ModifiableRootModel;
 import com.intellij.openapi.roots.libraries.Library;
-import com.intellij.openapi.roots.ui.configuration.projectRoot.ModuleStructureConfigurable;
+import com.intellij.openapi.roots.ui.configuration.ProjectStructureConfigurable;
 import com.intellij.openapi.roots.ui.configuration.projectRoot.StructureConfigurableContext;

 import javax.swing.*;
@@ -29,15 +29,15 @@ import javax.swing.*;
 * @author nik
 */
 public class AddExistingCustomLibraryAction extends CustomLibraryActionBase {
-  private Library myLibrary;
+  private final Library myLibrary;

  public AddExistingCustomLibraryAction(Library library,
                                        Icon icon,
                                        CustomLibraryCreator creator,
                                        StructureConfigurableContext context,
-                                        ModuleStructureConfigurable moduleStructureConfigurable,
+                                        ProjectStructureConfigurable projectStructureConfigurable,
                                        Module module) {
-    super(library.getName(), null, icon, context, moduleStructureConfigurable, creator, module);
+    super(library.getName(), null, icon, context, projectStructureConfigurable, creator, module);
    myLibrary = library;
  }

@@ -48,6 +48,6 @@ public class AddExistingCustomLibraryAction extends CustomLibraryActionBase {
      return;
    }
    final LibraryOrderEntry orderEntry = rootModel.addLibraryEntry(myLibrary);
-    myModuleStructureConfigurable.selectOrderEntry(myModule, orderEntry);
+    myProjectStructureConfigurable.selectOrderEntry(myModule, orderEntry);
  }
 }
@@ -29,12 +29,14 @@ import com.intellij.openapi.roots.libraries.Library;
 import com.intellij.openapi.roots.libraries.LibraryKind;
 import com.intellij.openapi.roots.libraries.LibraryTable;
 import com.intellij.openapi.roots.libraries.LibraryTablesRegistrar;
+import com.intellij.openapi.roots.ui.configuration.ProjectStructureConfigurable;
 import com.intellij.openapi.roots.ui.configuration.libraryEditor.CreateNewLibraryDialog;
 import com.intellij.openapi.roots.ui.configuration.libraryEditor.NewLibraryEditor;
 import com.intellij.openapi.roots.ui.configuration.projectRoot.LibrariesContainer;
 import com.intellij.openapi.roots.ui.configuration.projectRoot.LibrariesContainerFactory;
 import com.intellij.openapi.roots.ui.configuration.projectRoot.ModuleStructureConfigurable;
 import com.intellij.openapi.roots.ui.configuration.projectRoot.StructureConfigurableContext;
+import com.intellij.ui.treeStructure.Tree;
 import org.jetbrains.annotations.NotNull;

 import javax.swing.*;
@@ -46,13 +48,14 @@ import java.util.*;
 public class CreateCustomLibraryAction extends CustomLibraryActionBase {
  private CreateCustomLibraryAction(final String name, CustomLibraryCreator creator,
                                   StructureConfigurableContext context,
-                                   ModuleStructureConfigurable moduleStructureConfigurable, Module module) {
-    super(name, null, creator.getIcon(), context, moduleStructureConfigurable, creator, module);
+                                   ProjectStructureConfigurable projectStructureConfigurable, Module module) {
+    super(name, null, creator.getIcon(), context, projectStructureConfigurable, creator, module);
  }

  @Override
  public void actionPerformed(AnActionEvent e) {
-    final NewLibraryConfiguration libraryConfiguration = myCreator.getDescription().createNewLibrary(myModuleStructureConfigurable.getTree(),
+    final Tree parentComponent = ModuleStructureConfigurable.getInstance(myContext.getProject()).getTree();
+    final NewLibraryConfiguration libraryConfiguration = myCreator.getDescription().createNewLibrary(parentComponent,
                                                                                                     null);
    if (libraryConfiguration == null) {
      return;
@@ -64,7 +67,7 @@ public class CreateCustomLibraryAction extends CustomLibraryActionBase {
    LibraryTablesRegistrar registrar = LibraryTablesRegistrar.getInstance();
    final Project project = myContext.getProject();
    final List<LibraryTable> tables = Arrays.asList(registrar.getLibraryTable(project), registrar.getLibraryTable());
-    final CreateNewLibraryDialog dialog = new CreateNewLibraryDialog(myModuleStructureConfigurable.getTree(), myContext, libraryEditor, tables, 0);
+    final CreateNewLibraryDialog dialog = new CreateNewLibraryDialog(parentComponent, myContext, libraryEditor, tables, 0);
    dialog.show();
    if (dialog.isOK()) {
      final Library library = dialog.createLibrary();
@@ -73,7 +76,7 @@ public class CreateCustomLibraryAction extends CustomLibraryActionBase {
        return;
      }
      final LibraryOrderEntry orderEntry = rootModel.addLibraryEntry(library);
-      myModuleStructureConfigurable.selectOrderEntry(myModule, orderEntry);
+      myProjectStructureConfigurable.selectOrderEntry(myModule, orderEntry);
    }
  }

@@ -81,6 +84,7 @@ public class CreateCustomLibraryAction extends CustomLibraryActionBase {
    final Module module = moduleStructureConfigurable.getSelectedModule();
    if (module == null) return Collections.emptyList();

+    final ProjectStructureConfigurable projectStructureConfigurable = ProjectStructureConfigurable.getInstance(module.getProject());
    final List<AnAction> actions = new ArrayList<AnAction>();
    final LibrariesContainer container = LibrariesContainerFactory.createContainer(context);
    for (CustomLibraryCreator creator : CustomLibraryCreator.EP_NAME.getExtensions()) {
@@ -98,15 +102,15 @@ public class CreateCustomLibraryAction extends CustomLibraryActionBase {
      final Predicate<Library> notAddedLibrariesCondition = LibraryEditingUtil.getNotAddedLibrariesCondition(context.getModulesConfigurator().getRootModel(module));
      final Collection<Library> librariesToAdd = Collections2.filter(libraries, Predicates.and(suitablePredicate, notAddedLibrariesCondition));
      if (librariesToAdd.isEmpty()) {
-        actions.add(new CreateCustomLibraryAction(creator.getDisplayName(), creator, context, moduleStructureConfigurable, module));
+        actions.add(new CreateCustomLibraryAction(creator.getDisplayName(), creator, context, projectStructureConfigurable, module));
      }
      else {
        final DefaultActionGroup group = new DefaultActionGroup(creator.getDisplayName(), true);
        group.getTemplatePresentation().setIcon(creator.getIcon());
-        group.add(new CreateCustomLibraryAction("New...", creator, context, moduleStructureConfigurable, module));
+        group.add(new CreateCustomLibraryAction("New...", creator, context, projectStructureConfigurable, module));
        for (Library library : librariesToAdd) {
          Icon icon = LibraryPresentationManager.getInstance().getNamedLibraryIcon(library, context);
-          group.add(new AddExistingCustomLibraryAction(library, icon, creator, context, moduleStructureConfigurable, module));
+          group.add(new AddExistingCustomLibraryAction(library, icon, creator, context, projectStructureConfigurable, module));
        }
        actions.add(group);
      }
@@ -21,9 +21,9 @@ import com.intellij.openapi.roots.LibraryOrderEntry;
 import com.intellij.openapi.roots.ModifiableRootModel;
 import com.intellij.openapi.roots.OrderEntry;
 import com.intellij.openapi.roots.libraries.Library;
+import com.intellij.openapi.roots.ui.configuration.ProjectStructureConfigurable;
 import com.intellij.openapi.roots.ui.configuration.projectRoot.LibrariesContainer;
 import com.intellij.openapi.roots.ui.configuration.projectRoot.LibrariesContainerFactory;
-import com.intellij.openapi.roots.ui.configuration.projectRoot.ModuleStructureConfigurable;
 import com.intellij.openapi.roots.ui.configuration.projectRoot.StructureConfigurableContext;
 import com.intellij.openapi.ui.Messages;
 import org.jetbrains.annotations.NotNull;
@@ -38,14 +38,14 @@ import java.util.List;
 public abstract class CustomLibraryActionBase extends DumbAwareAction {
  protected final CustomLibraryCreator myCreator;
  protected final StructureConfigurableContext myContext;
-  protected final ModuleStructureConfigurable myModuleStructureConfigurable;
-  protected Module myModule;
+  protected final ProjectStructureConfigurable myProjectStructureConfigurable;
+  protected final Module myModule;

  protected CustomLibraryActionBase(String text, String description, Icon icon, StructureConfigurableContext context,
-                                    ModuleStructureConfigurable moduleStructureConfigurable, CustomLibraryCreator creator, Module module) {
+                                    ProjectStructureConfigurable projectStructureConfigurable, CustomLibraryCreator creator, Module module) {
    super(text, description, icon);
    myContext = context;
-    myModuleStructureConfigurable = moduleStructureConfigurable;
+    myProjectStructureConfigurable = projectStructureConfigurable;
    myCreator = creator;
    myModule = module;
  }
@@ -130,7 +130,7 @@ public class ModuleConfigurable extends ProjectStructureElementConfigurable<Modu
    //do nothing
  }

-  ModuleEditor getModuleEditor() {
+  public ModuleEditor getModuleEditor() {
    return myConfigurator.getModuleEditor(myModule);
  }

@@ -30,7 +30,10 @@ import com.intellij.ide.util.projectWizard.ProjectWizardUtil;
 import com.intellij.openapi.actionSystem.*;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.components.ServiceManager;
-import com.intellij.openapi.module.*;
+import com.intellij.openapi.module.ModifiableModuleModel;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.module.ModuleManager;
+import com.intellij.openapi.module.ModuleType;
 import com.intellij.openapi.options.ConfigurationException;
 import com.intellij.openapi.project.DumbAware;
 import com.intellij.openapi.project.Project;
@@ -40,17 +43,14 @@ import com.intellij.openapi.roots.impl.ClonableOrderEntry;
 import com.intellij.openapi.roots.impl.ProjectRootManagerImpl;
 import com.intellij.openapi.roots.impl.RootModelImpl;
 import com.intellij.openapi.roots.libraries.Library;
-import com.intellij.openapi.roots.ui.configuration.ClasspathEditor;
 import com.intellij.openapi.roots.ui.configuration.ModuleEditor;
 import com.intellij.openapi.roots.ui.configuration.ModulesConfigurator;
-import com.intellij.openapi.roots.ui.configuration.ProjectStructureConfigurable;
 import com.intellij.openapi.roots.ui.configuration.libraries.CreateCustomLibraryAction;
 import com.intellij.openapi.roots.ui.configuration.projectRoot.daemon.LibraryProjectStructureElement;
 import com.intellij.openapi.roots.ui.configuration.projectRoot.daemon.ModuleProjectStructureElement;
 import com.intellij.openapi.roots.ui.configuration.projectRoot.daemon.ProjectStructureDaemonAnalyzer;
 import com.intellij.openapi.roots.ui.configuration.projectRoot.daemon.ProjectStructureElement;
 import com.intellij.openapi.ui.DialogWrapper;
-import com.intellij.openapi.ui.MasterDetailsComponent;
 import com.intellij.openapi.ui.Messages;
 import com.intellij.openapi.ui.NamedConfigurable;
 import com.intellij.openapi.util.Comparing;
@@ -392,25 +392,6 @@ public class ModuleStructureConfigurable extends BaseStructureConfigurable imple
    return myProject;
  }

-  public void selectOrderEntry(@NotNull final Module module, @Nullable final OrderEntry orderEntry) {
-    ProjectStructureConfigurable.getInstance(myProject).select(module.getName(), null, true).doWhenDone(new Runnable() {
-      public void run() {
-        final MyNode node = findModuleNode(module);
-        if (node != null) {
-          ModuleConfigurable moduleConfigurable = (ModuleConfigurable)node.getConfigurable();
-          ModuleEditor moduleEditor = moduleConfigurable.getModuleEditor();
-          moduleEditor.setSelectedTabName(ClasspathEditor.NAME);
-          if (orderEntry != null) {
-            ModuleConfigurationEditor editor = moduleEditor.getEditor(ClasspathEditor.NAME);
-            if (editor instanceof ClasspathEditor) {
-              ((ClasspathEditor)editor).selectOrderEntry(orderEntry);
-            }
-          }
-        }
-      }
-    });
-  }
-
  public Module[] getModules() {
    if (myContext.myModulesConfigurator != null) {
      final ModifiableModuleModel model = myContext.myModulesConfigurator.getModuleModel();
@@ -5,7 +5,7 @@ import com.intellij.openapi.roots.ModuleRootModel;
 import com.intellij.openapi.roots.OrderEntry;
 import com.intellij.openapi.roots.impl.OrderEntryUtil;
 import com.intellij.openapi.roots.ui.configuration.ModulesConfigurator;
-import com.intellij.openapi.roots.ui.configuration.projectRoot.ModuleStructureConfigurable;
+import com.intellij.openapi.roots.ui.configuration.ProjectStructureConfigurable;
 import com.intellij.openapi.roots.ui.configuration.projectRoot.StructureConfigurableContext;
 import org.jetbrains.annotations.NotNull;

@@ -65,7 +65,7 @@ public class UsageInModuleClasspath extends ProjectStructureElementUsage {
    else {
      entry = null;
    }
-    ModuleStructureConfigurable.getInstance(myContext.getProject()).selectOrderEntry(myModule, entry);
+    ProjectStructureConfigurable.getInstance(myContext.getProject()).selectOrderEntry(myModule, entry);
  }

  @Override
@@ -26,7 +26,6 @@ import com.intellij.codeInsight.lookup.LookupManager;
 import com.intellij.ide.BrowserUtil;
 import com.intellij.ide.DataManager;
 import com.intellij.ide.IdeEventQueue;
-import com.intellij.ide.projectView.impl.nodes.NamedLibraryElement;
 import com.intellij.ide.util.PropertiesComponent;
 import com.intellij.ide.util.gotoByName.ChooseByNameBase;
 import com.intellij.lang.Language;
@@ -848,7 +847,7 @@ public class DocumentationManager {
        final VirtualFile virtualFile = containingFile.getVirtualFile();
        final OrderEntry libraryEntry = LibraryUtil.findLibraryEntry(virtualFile, myProject);
        if (libraryEntry != null) {
-          ProjectSettingsService.getInstance(myProject).openProjectLibrarySettings(new NamedLibraryElement(libraryEntry.getOwnerModule(), libraryEntry));
+          ProjectSettingsService.getInstance(myProject).openLibraryOrSdkSettings(libraryEntry);
        }
      }
    } else if (url.startsWith(PSI_ELEMENT_PROTOCOL)) {
@@ -50,10 +50,6 @@ public class NamedLibraryElementNode extends ProjectViewNode<NamedLibraryElement
    super(project, value, viewSettings);
  }

-  public NamedLibraryElementNode(final Project project, final Object value, final ViewSettings viewSettings) {
-    this(project, (NamedLibraryElement)value, viewSettings);
-  }
-
  @NotNull
  public Collection<AbstractTreeNode> getChildren() {
    final List<AbstractTreeNode> children = new ArrayList<AbstractTreeNode>();
@@ -107,22 +103,24 @@ public class NamedLibraryElementNode extends ProjectViewNode<NamedLibraryElement
      final JdkOrderEntry jdkOrderEntry = (JdkOrderEntry)orderEntry;
      final Sdk projectJdk = jdkOrderEntry.getJdk();
      if (projectJdk != null) { //jdk not specified
-        presentation.setLocationString(FileUtil.toSystemDependentName(projectJdk.getHomePath()));
+        final String path = projectJdk.getHomePath();
+        if (path != null) {
+          presentation.setLocationString(FileUtil.toSystemDependentName(path));
+        }
      }
+      presentation.setTooltip(IdeBundle.message("node.projectview.jdk"));
+    }
+    else {
+      presentation.setTooltip(StringUtil.capitalize(IdeBundle.message("node.projectview.library", ((LibraryOrderEntry)orderEntry).getLibraryLevel())));
    }
  }

-  protected String getToolTip() {
-    OrderEntry orderEntry = getValue().getOrderEntry();
-    return orderEntry instanceof JdkOrderEntry ? IdeBundle.message("node.projectview.jdk") : StringUtil.capitalize(IdeBundle.message("node.projectview.library", ((LibraryOrderEntry)orderEntry).getLibraryLevel()));
-  }
-
  public void navigate(final boolean requestFocus) {
-    ProjectSettingsService.getInstance(myProject).openProjectLibrarySettings(getValue());
+    ProjectSettingsService.getInstance(myProject).openLibraryOrSdkSettings(getValue().getOrderEntry());
  }

  public boolean canNavigate() {
-    return ProjectSettingsService.getInstance(myProject).canOpenProjectLibrarySettings(getValue());
+    return ProjectSettingsService.getInstance(myProject).canOpenLibraryOrSdkSettings(getValue().getOrderEntry());
  }

  @Override
@@ -28,8 +28,10 @@ import com.intellij.openapi.module.Module;
 import com.intellij.openapi.module.ModuleUtil;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.project.ProjectUtil;
+import com.intellij.openapi.roots.OrderEntry;
 import com.intellij.openapi.roots.ProjectFileIndex;
 import com.intellij.openapi.roots.ProjectRootManager;
+import com.intellij.openapi.roots.libraries.LibraryUtil;
 import com.intellij.openapi.roots.ui.configuration.ProjectSettingsService;
 import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.Iconable;
@@ -218,7 +220,10 @@ public class PsiDirectoryNode extends BasePsiNode<PsiDirectory> implements Navig
        service.openModuleSettings(module);
      }
      else if (ProjectRootsUtil.isLibraryRoot(file, project)) {
-        service.openModuleLibrarySettings(module);
+        final OrderEntry orderEntry = LibraryUtil.findLibraryEntry(file, module.getProject());
+        if (orderEntry != null) {
+          service.openLibraryOrSdkSettings(orderEntry);
+        }
      }
      else {
        service.openContentEntriesSettings(module);
@@ -19,13 +19,18 @@ package com.intellij.ide.projectView.impl.nodes;
 import com.intellij.ide.highlighter.ArchiveFileType;
 import com.intellij.ide.projectView.PresentationData;
 import com.intellij.ide.projectView.ViewSettings;
+import com.intellij.ide.projectView.impl.ProjectRootsUtil;
 import com.intellij.ide.util.treeView.AbstractTreeNode;
 import com.intellij.openapi.fileTypes.StdFileTypes;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.project.ProjectUtil;
+import com.intellij.openapi.roots.OrderEntry;
+import com.intellij.openapi.roots.libraries.LibraryUtil;
+import com.intellij.openapi.roots.ui.configuration.ProjectSettingsService;
 import com.intellij.openapi.util.Iconable;
 import com.intellij.openapi.vfs.JarFileSystem;
 import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.pom.NavigatableWithText;
 import com.intellij.psi.PsiDirectory;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiManager;
@@ -36,20 +41,18 @@ import org.jetbrains.annotations.Nullable;
 import java.util.ArrayList;
 import java.util.Collection;

-public class PsiFileNode extends BasePsiNode<PsiFile>{
+public class PsiFileNode extends BasePsiNode<PsiFile> implements NavigatableWithText {

  public PsiFileNode(Project project, PsiFile value, ViewSettings viewSettings) {
    super(project, value, viewSettings);
  }

  public Collection<AbstractTreeNode> getChildrenImpl() {
-    if (isArchive()) {
-      VirtualFile jarRoot = JarFileSystem.getInstance().getJarRootForLocalFile(getVirtualFile());
-      if (jarRoot != null) {
-        PsiDirectory psiDirectory = PsiManager.getInstance(getProject()).findDirectory(jarRoot);
-        if (psiDirectory != null) {
-          return ProjectViewDirectoryHelper.getInstance(getProject()).getDirectoryChildren(psiDirectory, getSettings(), true);
-        }
+    VirtualFile jarRoot = getJarRoot();
+    if (jarRoot != null) {
+      PsiDirectory psiDirectory = PsiManager.getInstance(getProject()).findDirectory(jarRoot);
+      if (psiDirectory != null) {
+        return ProjectViewDirectoryHelper.getInstance(getProject()).getDirectoryChildren(psiDirectory, getSettings(), true);
      }
    }

@@ -72,6 +75,52 @@ public class PsiFileNode extends BasePsiNode<PsiFile>{
    return value != null ? value.getVirtualFile() : null;
  }

+  @Override
+  public boolean canNavigate() {
+    return isNavigatableLibraryRoot() || super.canNavigate();
+  }
+
+  private boolean isNavigatableLibraryRoot() {
+    VirtualFile jarRoot = getJarRoot();
+    final Project project = getProject();
+    if (jarRoot != null && ProjectRootsUtil.isLibraryRoot(jarRoot, project)) {
+      final OrderEntry orderEntry = LibraryUtil.findLibraryEntry(jarRoot, project);
+      return orderEntry != null && ProjectSettingsService.getInstance(project).canOpenLibraryOrSdkSettings(orderEntry);
+    }
+    return false;
+  }
+
+  @Nullable
+  private VirtualFile getJarRoot() {
+    final VirtualFile file = getVirtualFile();
+    if (file == null || !file.isValid() || !(file.getFileType() instanceof ArchiveFileType)) {
+      return null;
+    }
+    return JarFileSystem.getInstance().getJarRootForLocalFile(file);
+  }
+
+  @Override
+  public void navigate(boolean requestFocus) {
+    VirtualFile jarRoot = getJarRoot();
+    final Project project = getProject();
+    if (jarRoot != null && ProjectRootsUtil.isLibraryRoot(jarRoot, project)) {
+      final OrderEntry orderEntry = LibraryUtil.findLibraryEntry(jarRoot, project);
+      if (orderEntry != null) {
+        ProjectSettingsService.getInstance(project).openLibraryOrSdkSettings(orderEntry);
+        return;
+      }
+    }
+    super.navigate(requestFocus);
+  }
+
+  @Override
+  public String getNavigateActionText(boolean focusEditor) {
+    if (isNavigatableLibraryRoot()) {
+      return "Open Library Settings";
+    }
+    return null;
+  }
+
  public int getWeight() {
    return 20;
  }
@@ -15,7 +15,6 @@
 */
 package com.intellij.openapi.roots.libraries;

-import com.intellij.ide.projectView.impl.nodes.NamedLibraryElement;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.roots.LibraryOrderEntry;
 import com.intellij.openapi.roots.ModuleRootManager;
@@ -29,14 +28,14 @@ import org.jetbrains.annotations.NotNull;
 */
 public class LibraryNavigatable implements Navigatable {
  private final Module module;
-  private NamedLibraryElement element;
+  private OrderEntry element;

  public LibraryNavigatable(@NotNull Library library, @NotNull Module module) {
    this.module = module;
    for (OrderEntry entry : ModuleRootManager.getInstance(module).getOrderEntries()) {
      if (entry instanceof LibraryOrderEntry) {
        if (((LibraryOrderEntry)entry).getLibrary() == library) {
-          element = new NamedLibraryElement(module, entry);
+          element = entry;
        }
      }
    }
@@ -44,7 +43,7 @@ public class LibraryNavigatable implements Navigatable {

  @Override
  public void navigate(boolean requestFocus) {
-    ProjectSettingsService.getInstance(module.getProject()).openProjectLibrarySettings(element);
+    ProjectSettingsService.getInstance(module.getProject()).openLibraryOrSdkSettings(element);
  }

  @Override
@@ -17,7 +17,6 @@
 package com.intellij.openapi.roots.ui.configuration;

 import com.intellij.ide.projectView.impl.ModuleGroup;
-import com.intellij.ide.projectView.impl.nodes.NamedLibraryElement;
 import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.options.Configurable;
@@ -29,7 +28,6 @@ import com.intellij.openapi.roots.OrderEntry;
 import com.intellij.openapi.roots.impl.libraries.LibraryEx;
 import com.intellij.openapi.roots.libraries.Library;
 import com.intellij.openapi.roots.libraries.LibraryType;
-import com.intellij.openapi.roots.libraries.ui.LibraryRootsComponentDescriptor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

@@ -72,22 +70,20 @@ public class ProjectSettingsService {
    return false;
  }

-  public void openProjectLibrarySettings(final NamedLibraryElement value) {
-    Configurable additionalSettingsConfigurable = getLibrarySettingsConfigurable(value);
+  public void openLibraryOrSdkSettings(final @NotNull OrderEntry orderEntry) {
+    Configurable additionalSettingsConfigurable = getLibrarySettingsConfigurable(orderEntry);
    if (additionalSettingsConfigurable != null) {
-      LibraryOrderEntry entry = (LibraryOrderEntry) value.getOrderEntry();
-      ShowSettingsUtil.getInstance()
-        .showSettingsDialog(entry.getOwnerModule().getProject(), additionalSettingsConfigurable.getDisplayName());
+      ShowSettingsUtil.getInstance().showSettingsDialog(orderEntry.getOwnerModule().getProject(),
+                                                        additionalSettingsConfigurable.getDisplayName());
    }
  }

-  public boolean canOpenProjectLibrarySettings(final NamedLibraryElement value) {
-    return getLibrarySettingsConfigurable(value) != null;
+  public boolean canOpenLibraryOrSdkSettings(final OrderEntry orderEntry) {
+    return getLibrarySettingsConfigurable(orderEntry) != null;
  }

  @Nullable
-  private static Configurable getLibrarySettingsConfigurable(NamedLibraryElement value) {
-    OrderEntry orderEntry = value.getOrderEntry();
+  private static Configurable getLibrarySettingsConfigurable(OrderEntry orderEntry) {
    if (!(orderEntry instanceof LibraryOrderEntry)) return null;
    LibraryOrderEntry libOrderEntry = (LibraryOrderEntry)orderEntry;
    Library lib = libOrderEntry.getLibrary();