import com.intellij.openapi.roots.libraries.ui.OrderRoot; //导入依赖的package包/类
private Library createLibraryFromRoots(List<OrderRoot> roots, @Nullable final LibraryType libraryType) {
  final PersistentLibraryKind kind = libraryType == null ? null : libraryType.getKind();
  final Library library = myModuleLibrariesModel.createLibrary(null, kind);
  final LibraryEx.ModifiableModelEx libModel = (LibraryEx.ModifiableModelEx)library.getModifiableModel();
  if (myDefaultPropertiesFactory != null) {
    libModel.setProperties(myDefaultPropertiesFactory.fun(libraryType));
  }
  for (OrderRoot root : roots) {
    if (root.isJarDirectory()) {
      libModel.addJarDirectory(root.getFile(), false, root.getType());
    }
    else {
      libModel.addRoot(root.getFile(), root.getType());
    }
  }
  libModel.commit();
  return library;
}
 

import com.intellij.openapi.roots.libraries.ui.OrderRoot; //导入依赖的package包/类
@Nullable
private Module findModule(List<OrderRoot> roots) {
  for (OrderRoot root : roots) {
    Module module = null;
    final VirtualFile local = JarFileSystem.getInstance().getVirtualFileForJar(root.getFile());
    if (local != null) {
      module = ModuleUtil.findModuleForFile(local, myProject);
    }
    if (module == null) {
      module = ModuleUtil.findModuleForFile(root.getFile(), myProject);
    }
    if (module != null) {
      return module;
    }
  }
  return null;
}
 

import com.intellij.openapi.roots.libraries.ui.OrderRoot; //导入依赖的package包/类
@Override
public NewLibraryConfiguration createLibraryFromFiles(@NotNull LibraryRootsComponentDescriptor descriptor,
                                                      @NotNull JComponent parentComponent,
                                                      @Nullable VirtualFile contextDirectory,
                                                      LibraryType<?> type,
                                                      final Project project) {
  final FileChooserDescriptor chooserDescriptor = descriptor.createAttachFilesChooserDescriptor(null);
  chooserDescriptor.setTitle("Select Library Files");
  final VirtualFile[] rootCandidates = FileChooser.chooseFiles(chooserDescriptor, parentComponent, project, contextDirectory);
  if (rootCandidates.length == 0) {
    return null;
  }

  final List<OrderRoot> roots = RootDetectionUtil.detectRoots(Arrays.asList(rootCandidates), parentComponent, project, descriptor);
  if (roots.isEmpty()) return null;
  String name = suggestLibraryName(roots);
  return doCreate(type, name, roots);
}
 

import com.intellij.openapi.roots.libraries.ui.OrderRoot; //导入依赖的package包/类
private static boolean addJavaDocAndSources(@NotNull List<OrderRoot> orderRoots, @NotNull VirtualFile dir) {
  boolean found = false;

  VirtualFile javadocDir = findJavadocDir(dir);
  if (javadocDir != null) {
    orderRoots.add(new OrderRoot(javadocDir, JavadocOrderRootType.getInstance()));
    found = true;
  }

  VirtualFile sourcesDir = dir.findChild(FD_SOURCES);
  if (sourcesDir != null) {
    orderRoots.add(new OrderRoot(sourcesDir, SOURCES));
    found = true;
  }
  return found;
}
 

import com.intellij.openapi.roots.libraries.ui.OrderRoot; //导入依赖的package包/类
@Override
public void actionPerformed(@NotNull AnActionEvent e) {
  final Project project = getEventProject(e);
  if (project == null) return;

  if (!Projects.isGradleProject(project)) {
    myDelegate.actionPerformed(e);
    return;
  }

  final List<VirtualFile> jars = getRoots(e);
  if (jars.isEmpty()) {
    return;
  }

  final List<OrderRoot> roots = RootDetectionUtil.detectRoots(jars, null, project, new DefaultLibraryRootsComponentDescriptor());
  new CreateGradleLibraryFromFilesDialog(project, roots).show();
}
 

import com.intellij.openapi.roots.libraries.ui.OrderRoot; //导入依赖的package包/类
public CreateGradleLibraryFromFilesDialog(@NotNull Project project, @NotNull List<OrderRoot> roots) {
  super(project, true);
  setTitle(COMMAND_TITLE);
  myProject = project;
  myRoots = roots;
  mySettingsFile = GradleSettingsFile.get(myProject);

  final FormBuilder builder = LibraryNameAndLevelPanel.createFormBuilder();
  myModulesComboBox = new ModulesComboBox();
  myModulesComboBox.fillModules(myProject);
  myModulesComboBox.setSelectedModule(findModule(roots));
  for (Iterator iter = ((SortedListModel)myModulesComboBox.getModel()).iterator(); iter.hasNext(); ) {
    Module module = (Module)iter.next();
    String path = GradleSettingsFile.getModuleGradlePath(module);
    if (path == null || !mySettingsFile.hasBuildFile(path)) {
      iter.remove();
    }
  }
  builder.addLabeledComponent("&Add to module:", myModulesComboBox);
  myPanel = builder.getPanel();
  init();
}
 

import com.intellij.openapi.roots.libraries.ui.OrderRoot; //导入依赖的package包/类
@Nullable
private Module findModule(List<OrderRoot> roots) {
  for (OrderRoot root : roots) {
    Module module = null;
    final VirtualFile local = JarFileSystem.getInstance().getVirtualFileForJar(root.getFile());
    if (local != null) {
      module = ModuleUtilCore.findModuleForFile(local, myProject);
    }
    if (module == null) {
      module = ModuleUtilCore.findModuleForFile(root.getFile(), myProject);
    }
    if (module != null) {
      return module;
    }
  }
  return null;
}
 

import com.intellij.openapi.roots.libraries.ui.OrderRoot; //导入依赖的package包/类
public static NewLibraryConfiguration resolveAndDownload(final Project project,
                                                         final String coord,
                                                         boolean attachJavaDoc,
                                                         boolean attachSources,
                                                         @Nullable final String copyTo,
                                                         List<MavenRepositoryInfo> repositories) {
  RepositoryLibraryProperties libraryProperties = new RepositoryLibraryProperties(coord);
  final List<OrderRoot> roots = MavenDependenciesRemoteManager.getInstance(project)
    .downloadDependenciesModal(libraryProperties, attachSources, attachJavaDoc, copyTo);
  if (roots == null || roots.size() == 0) {
    return null;
  }
  notifyArtifactsDownloaded(project, roots);
  RepositoryLibraryDescription libraryDescription = RepositoryLibraryDescription.findDescription(libraryProperties);
  return new NewLibraryConfiguration(
    libraryDescription.getDisplayName(libraryProperties.getVersion()),
    RepositoryLibraryType.getInstance(),
    new RepositoryLibraryProperties(coord)) {
    @Override
    public void addRoots(@NotNull LibraryEditor editor) {
      editor.addRoots(roots);
    }
  };
}
 

import com.intellij.openapi.roots.libraries.ui.OrderRoot; //导入依赖的package包/类
@NotNull
private static List<OrderRoot> getLibraryRootsForVersion(@Nullable final DefracVersion defracVersion) {
  if(defracVersion == null) {
    return Collections.emptyList();
  }

  final List<OrderRoot> result = Lists.newLinkedList();

  for(final VirtualFile library : defracVersion.getLibraries()) {
    result.add(new OrderRoot(library, OrderRootType.CLASSES));
  }

  for(final DefracPlatform platform : DefracPlatform.values()) {
    final VirtualFile javadoc =
        VirtualFileManager.getInstance().
            findFileByUrl(getJavadocUrl(defracVersion, platform));

    if(null != javadoc) {
      result.add(new OrderRoot(javadoc, JavadocOrderRootType.getInstance()));
    }
  }

  return result;
}
 

import com.intellij.openapi.roots.libraries.ui.OrderRoot; //导入依赖的package包/类
private Library createLibraryFromRoots(List<OrderRoot> roots, @Nullable final LibraryType libraryType) {
  final PersistentLibraryKind kind = libraryType == null ? null : libraryType.getKind();
  final Library library = ((LibraryTableBase.ModifiableModelEx)myModuleLibrariesModel).createLibrary(null, kind);
  final LibraryEx.ModifiableModelEx libModel = (LibraryEx.ModifiableModelEx)library.getModifiableModel();
  if (myDefaultPropertiesFactory != null) {
    libModel.setProperties(myDefaultPropertiesFactory.fun(libraryType));
  }
  for (OrderRoot root : roots) {
    if (root.isJarDirectory()) {
      libModel.addJarDirectory(root.getFile(), false, root.getType());
    }
    else {
      libModel.addRoot(root.getFile(), root.getType());
    }
  }
  libModel.commit();
  return library;
}
 

import com.intellij.openapi.roots.libraries.ui.OrderRoot; //导入依赖的package包/类
@Nullable
public static NewLibraryConfiguration attachLibrary(final @NotNull Project project,
                                                    List<DeftRegistryEntryInfo> registryEntries) {
  final Ref<NewLibraryConfiguration> result = Ref.create(null);

  for (DeftRegistryEntryInfo registryEntry : registryEntries) {
    AccessToken accessToken = WriteAction.start();
    try {
      final List<OrderRoot> roots = createRoots(registryEntry);

      result.set(new NewLibraryConfiguration(registryEntry.getLibraryName(),
                     DeftLibraryType.getInstance(),
                     new DeftLibraryProperties(registryEntry.getLibraryName())) {
                         @Override
                         public void addRoots(@NotNull LibraryEditor editor) {
                           editor.addRoots(roots);
                         }
                       });
    } finally {
      accessToken.finish();
    }
  }

  return result.get();
}
 

import com.intellij.openapi.roots.libraries.ui.OrderRoot; //导入依赖的package包/类
private Library createLibraryFromRoots(ModifiableModuleRootLayer layer, List<OrderRoot> roots, @Nullable final LibraryType libraryType) {
  final LibraryTable.ModifiableModel moduleLibraryModel = layer.getModuleLibraryTable().getModifiableModel();

  final PersistentLibraryKind kind = libraryType == null ? null : libraryType.getKind();
  final Library library = ((LibraryTableBase.ModifiableModelEx)moduleLibraryModel).createLibrary(null, kind);
  final LibraryEx.ModifiableModelEx libModel = (LibraryEx.ModifiableModelEx)library.getModifiableModel();

  for (OrderRoot root : roots) {
    if (root.isJarDirectory()) {
      libModel.addJarDirectory(root.getFile(), false, root.getType());
    }
    else {
      libModel.addRoot(root.getFile(), root.getType());
    }
  }
  libModel.commit();
  return library;
}
 

import com.intellij.openapi.roots.libraries.ui.OrderRoot; //导入依赖的package包/类
@Override
public NewLibraryConfiguration createLibraryFromFiles(@Nonnull LibraryRootsComponentDescriptor descriptor,
                                                      @Nonnull JComponent parentComponent,
                                                      @Nullable VirtualFile contextDirectory,
                                                      LibraryType<?> type,
                                                      final Project project) {
  final FileChooserDescriptor chooserDescriptor = descriptor.createAttachFilesChooserDescriptor(null);
  chooserDescriptor.setTitle("Select Library Files");
  final VirtualFile[] rootCandidates = FileChooser.chooseFiles(chooserDescriptor, parentComponent, project, contextDirectory);
  if (rootCandidates.length == 0) {
    return null;
  }

  final List<OrderRoot> roots = RootDetectionUtil.detectRoots(Arrays.asList(rootCandidates), parentComponent, project, descriptor);
  if (roots.isEmpty()) return null;
  String name = suggestLibraryName(roots);
  return doCreate(type, name, roots);
}
 

import com.intellij.openapi.roots.libraries.ui.OrderRoot; //导入依赖的package包/类
@Override
public Library createLibrary(@NotNull @NonNls String name,
                             @NotNull LibraryLevel level,
                             @NotNull Collection<? extends OrderRoot> roots) {
  final NewLibraryEditor editor = new NewLibraryEditor();
  editor.setName(name);
  editor.addRoots(roots);
  return createLibrary(editor, level);
}
 

import com.intellij.openapi.roots.libraries.ui.OrderRoot; //导入依赖的package包/类
@Override
public void addRoots(Collection<? extends OrderRoot> roots) {
  for (OrderRoot root : roots) {
    if (root.isJarDirectory()) {
      addJarDirectory(root.getFile(), false, root.getType());
    }
    else {
      addRoot(root.getFile(), root.getType());
    }
  }
}
 

import com.intellij.openapi.roots.libraries.ui.OrderRoot; //导入依赖的package包/类
/**
 * This method takes a candidates for the project root, then scans the candidates and
 * if multiple candidates or non root source directories are found whithin some
 * directories, it shows a dialog that allows selecting or deselecting them.
 * @param parent a parent parent or project
 * @param rootCandidates a candidates for roots
 * @return a array of source folders or empty array if non was selected or dialog was canceled.
 */
public static VirtualFile[] scanAndSelectDetectedJavaSourceRoots(Component parentComponent, final VirtualFile[] rootCandidates) {
  final List<OrderRoot> orderRoots = RootDetectionUtil.detectRoots(Arrays.asList(rootCandidates), parentComponent, null,
                                                                   new LibraryRootsDetectorImpl(Collections.singletonList(JAVA_SOURCE_ROOT_DETECTOR)),
                                                                   new OrderRootType[0]);
  final List<VirtualFile> result = new ArrayList<VirtualFile>();
  for (OrderRoot root : orderRoots) {
    result.add(root.getFile());
  }
  return VfsUtil.toVirtualFileArray(result);
}
 

import com.intellij.openapi.roots.libraries.ui.OrderRoot; //导入依赖的package包/类
private List<OrderRoot> filterAlreadyAdded(final List<OrderRoot> roots) {
  if (roots == null || roots.isEmpty()) {
    return Collections.emptyList();
  }

  final List<OrderRoot> result = new ArrayList<OrderRoot>();
  final Library[] libraries = myModuleLibrariesModel.getLibraries();
  for (OrderRoot root : roots) {
    if (!isIncluded(root, libraries)) {
      result.add(root);
    }
  }
  return result;
}
 

import com.intellij.openapi.roots.libraries.ui.OrderRoot; //导入依赖的package包/类
private static boolean isIncluded(OrderRoot root, Library[] libraries) {
  for (Library library : libraries) {
    if (ArrayUtil.contains(root.getFile(), library.getFiles(root.getType()))) {
      return true;
    }
  }
  return false;
}
 

import com.intellij.openapi.roots.libraries.ui.OrderRoot; //导入依赖的package包/类
@Override
public void actionPerformed(AnActionEvent e) {
  final Project project = getEventProject(e);
  if (project == null) return;

  final List<VirtualFile> jars = getRoots(e);
  if (jars.isEmpty()) return;

  final List<OrderRoot> roots = RootDetectionUtil.detectRoots(jars, null, project, new DefaultLibraryRootsComponentDescriptor());
  new CreateLibraryFromFilesDialog(project, roots).show();
}
 

import com.intellij.openapi.roots.libraries.ui.OrderRoot; //导入依赖的package包/类
@NotNull
public static List<OrderRoot> detectRoots(@NotNull final Collection<VirtualFile> rootCandidates,
                                          @Nullable Component parentComponent,
                                          @Nullable Project project,
                                          @NotNull final LibraryRootsComponentDescriptor rootsComponentDescriptor) {
  return detectRoots(rootCandidates, parentComponent, project, rootsComponentDescriptor.getRootsDetector(),
                     rootsComponentDescriptor.getRootTypes());
}