Java LibraryEditor类代码示例

import com.intellij.openapi.roots.ui.configuration.libraryEditor.LibraryEditor; //导入依赖的package包/类
@Override
public JComponent createOptionsPanel() {
  myLibraryEditorComponent = new LibraryRootsComponent(myProject, new Computable<LibraryEditor>() {
    @Override
    public LibraryEditor compute() {
      return getLibraryEditor();
    }
  });
  myLibraryEditorComponent.addListener(new Runnable() {
    @Override
    public void run() {
      myContext.getDaemonAnalyzer().queueUpdate(myProjectStructureElement);
      updateName();
    }
  });
  return myLibraryEditorComponent.getComponent();
}
 

import com.intellij.openapi.roots.ui.configuration.libraryEditor.LibraryEditor; //导入依赖的package包/类
@Nullable
private String getPresentableVersion() {
  switch (myButtonEnumModel.getSelected()) {
    case DOWNLOAD:
      LibraryDownloadSettings settings = mySettings.getDownloadSettings();
      if (settings != null) {
        return settings.getVersion().getVersionNumber();
      }
      break;
    case USE_LIBRARY:
      LibraryEditor item = myLibraryComboBoxModel.getSelectedItem();
      if (item instanceof ExistingLibraryEditor) {
        return item.getName();
      }
      break;
    default:
      return null;
  }
  return null;
}
 

import com.intellij.openapi.roots.ui.configuration.libraryEditor.LibraryEditor; //导入依赖的package包/类
public EditLibraryDialog(Component parent, LibraryCompositionSettings settings, final LibraryEditor libraryEditor) {
  super(parent, true);
  mySettings = settings;
  myLibraryEditor = libraryEditor;
  myLibraryRootsComponent = new LibraryRootsComponent(null, libraryEditor);
  myLibraryRootsComponent.resetProperties();

  Disposer.register(getDisposable(), myLibraryRootsComponent);

  final boolean newLibrary = libraryEditor instanceof NewLibraryEditor;
  setTitle((newLibrary ? "Create" : "Edit") + " Library");

  myBuilder = LibraryNameAndLevelPanel.createFormBuilder();
  myNameAndLevelPanel = new LibraryNameAndLevelPanel(myBuilder, libraryEditor.getName(), newLibrary ? settings.getNewLibraryLevel() : null);
  init();
}
 

import com.intellij.openapi.roots.ui.configuration.libraryEditor.LibraryEditor; //导入依赖的package包/类
@Override
public NewLibraryConfiguration createNewLibrary(@NotNull JComponent parentComponent, VirtualFile contextDirectory) {
  final FileChooserDescriptor descriptor = new FileChooserDescriptor(false, false, true, false, false, true);
  descriptor.setTitle(IdeBundle.message("new.library.file.chooser.title"));
  descriptor.setDescription(IdeBundle.message("new.library.file.chooser.description"));
  final VirtualFile[] files = FileChooser.chooseFiles(descriptor, parentComponent, null, contextDirectory);
  if (files.length == 0) {
    return null;
  }
  return new NewLibraryConfiguration(myDefaultLibraryName, getDownloadableLibraryType(), new LibraryVersionProperties()) {
    @Override
    public void addRoots(@NotNull LibraryEditor editor) {
      for (VirtualFile file : files) {
        editor.addRoot(file, OrderRootType.CLASSES);
      }
    }
  };
}
 

import com.intellij.openapi.roots.ui.configuration.libraryEditor.LibraryEditor; //导入依赖的package包/类
private void save() {
  if (myLibraryEditorComponent != null) {
    executeProjectChanges(myProject, new Runnable() {
      @Override
      public void run() {
        LibraryEditor editor = myLibraryEditorComponent.getLibraryEditor();
        Library.ModifiableModel libraryModel = myLibrary.getModifiableModel();
        try {
          addUrls(editor, libraryModel, SOURCES);
          addUrls(editor, libraryModel, JavadocOrderRootType.getInstance());
        }
        finally {
          libraryModel.commit();
        }
      }
    });
  }
}
 

import com.intellij.openapi.roots.ui.configuration.libraryEditor.LibraryEditor; //导入依赖的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.ui.configuration.libraryEditor.LibraryEditor; //导入依赖的package包/类
@Override
protected void fillLibrary(String path, LibraryEditor libraryEditor) {
  File srcRoot = new File(path + "/src/main");
    if (srcRoot.exists()) {
      libraryEditor.addRoot(VfsUtil.getUrlForLibraryRoot(srcRoot), OrderRootType.SOURCES);
    }

    File[] jars;
    File libDir = new File(path + "/lib");
    if (libDir.exists()) {
      jars = libDir.listFiles();
    } else {
      jars = new File(path + "/embeddable").listFiles();
    }
    if (jars != null) {
      for (File file : jars) {
        if (file.getName().endsWith(".jar")) {
          libraryEditor.addRoot(VfsUtil.getUrlForLibraryRoot(file), OrderRootType.CLASSES);
        }
      }
    }
}
 

import com.intellij.openapi.roots.ui.configuration.libraryEditor.LibraryEditor; //导入依赖的package包/类
@Override
protected void fillLibrary(String path, LibraryEditor libraryEditor) {
  File srcRoot = new File(path + "/src/main");
  if (srcRoot.exists()) {
    libraryEditor.addRoot(VfsUtil.getUrlForLibraryRoot(srcRoot), OrderRootType.SOURCES);
  }

  // Add Gant jars
  File lib = new File(path + "/lib");
  File[] jars = lib.exists() ? lib.listFiles() : new File[0];
  if (jars != null) {
    for (File file : jars) {
      if (file.getName().endsWith(".jar")) {
        libraryEditor.addRoot(VfsUtil.getUrlForLibraryRoot(file), OrderRootType.CLASSES);
      }
    }
  }
}
 

import com.intellij.openapi.roots.ui.configuration.libraryEditor.LibraryEditor; //导入依赖的package包/类
private static void addSources(LibraryEditor libraryEditor, File srcRoot) {
  File compilerSrc = new File(srcRoot, "Compiler/src");
  if (compilerSrc.exists()) {
    libraryEditor.addRoot(VfsUtil.getUrlForLibraryRoot(compilerSrc), OrderRootType.SOURCES);
  }

  File stdLibSrc = new File(srcRoot, "StdLib/src");
  if (stdLibSrc.exists()) {
    libraryEditor.addRoot(VfsUtil.getUrlForLibraryRoot(stdLibSrc), OrderRootType.SOURCES);
  }

  File mainSrc = new File(srcRoot, "main");
  if (mainSrc.exists()) {
    libraryEditor.addRoot(VfsUtil.getUrlForLibraryRoot(mainSrc), OrderRootType.SOURCES);
  }
}
 

import com.intellij.openapi.roots.ui.configuration.libraryEditor.LibraryEditor; //导入依赖的package包/类
@Override
public NewLibraryConfiguration createNewLibrary(@NotNull JComponent jComponent, @Nullable VirtualFile virtualFile,
                                                @NotNull Project project) {
    final FileChooserDescriptor descriptor = FileChooserDescriptorFactory.createAllButJarContentsDescriptor();
    descriptor.setTitle(LuaBundle.message("new.library.file.chooser.title"));
    descriptor.setDescription(LuaBundle.message("new.library.file.chooser.description"));
    final VirtualFile[] files = FileChooser.chooseFiles(descriptor, jComponent, project, virtualFile);
    if (files.length == 0) {
        return null;
    }
    return new NewLibraryConfiguration("Lua Library", this, new DummyLibraryProperties()) {
        @Override
        public void addRoots(@NotNull LibraryEditor editor) {
            for (VirtualFile file : files) {
                editor.addRoot(file, OrderRootType.CLASSES);
            }
        }
    };
}
 

import com.intellij.openapi.roots.ui.configuration.libraryEditor.LibraryEditor; //导入依赖的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.ui.configuration.libraryEditor.LibraryEditor; //导入依赖的package包/类
@Override
public void addRoots(@NotNull LibraryEditor editor)
{
    final List<File> libs = muleSdk.getLibraryEntries();
    for (File file : libs)
    {
        editor.addRoot(VfsUtil.getUrlForLibraryRoot(file), OrderRootType.CLASSES);
    }
}
 

import com.intellij.openapi.roots.ui.configuration.libraryEditor.LibraryEditor; //导入依赖的package包/类
@Override
public boolean isChanged() {
  for (LibraryEditor libraryEditor : myLibrary2EditorMap.values()) {
    if (libraryEditor.hasChanges()) return true;
  }
  return getLibrariesModifiableModel().isChanged();
}
 

import com.intellij.openapi.roots.ui.configuration.libraryEditor.LibraryEditor; //导入依赖的package包/类
private void doConfigure() {
  switch (myButtonEnumModel.getSelected()) {
    case DOWNLOAD:
      final LibraryDownloadSettings oldDownloadSettings = mySettings.getDownloadSettings();
      LOG.assertTrue(oldDownloadSettings != null);
      final LibraryDownloadSettings newDownloadSettings = DownloadingOptionsDialog.showDialog(myPanel, oldDownloadSettings,
                                                                                              mySettings.getCompatibleVersions(), true);
      if (newDownloadSettings != null) {
        mySettings.setDownloadSettings(newDownloadSettings);
      }
      break;

    case USE_LIBRARY:
      final Object item = myExistingLibraryComboBox.getSelectedItem();
      if (item instanceof LibraryEditor) {
        EditLibraryDialog dialog = new EditLibraryDialog(myPanel, mySettings, (LibraryEditor)item);
        dialog.show();
        if (item instanceof ExistingLibraryEditor) {
          new WriteAction() {
            protected void run(@NotNull final Result result) {
              ((ExistingLibraryEditor)item).commit();
            }
          }.execute();
        }
      }
      break;

    case USE_FROM_PROVIDER:
    case SETUP_LIBRARY_LATER:
      break;
  }
  updateState();
}
 

import com.intellij.openapi.roots.ui.configuration.libraryEditor.LibraryEditor; //导入依赖的package包/类
@Override
public VirtualFile[] selectFiles(final @NotNull JComponent parent, @Nullable VirtualFile initialSelection,
                                 final @Nullable Module contextModule, @NotNull LibraryEditor libraryEditor) {
  final FileChooserDescriptor chooserDescriptor = createChooserDescriptor();
  chooserDescriptor.setTitle(getChooserTitle(libraryEditor.getName()));
  chooserDescriptor.setDescription(getChooserDescription());
  if (contextModule != null) {
    chooserDescriptor.putUserData(LangDataKeys.MODULE_CONTEXT, contextModule);
  }
  return FileChooser.chooseFiles(chooserDescriptor, parent, contextModule != null ? contextModule.getProject() : null, initialSelection);
}