Java LibraryType类代码示例

import com.intellij.openapi.roots.libraries.LibraryType; //导入依赖的package包/类
@Override
public Library createLibrary(@NotNull NewLibraryEditor libraryEditor,
                             @NotNull LibraryLevel level) {
  LibraryTableModifiableModelProvider provider = getProvider(level);
  if (provider == null) {
    LOG.error("cannot create module library in this context");
  }

  LibraryTable.ModifiableModel model = provider.getModifiableModel();
  final LibraryType<?> type = libraryEditor.getType();
  Library library = model.createLibrary(getUniqueLibraryName(libraryEditor.getName(), model), type == null ? null : type.getKind());
  ExistingLibraryEditor createdLibraryEditor = ((LibrariesModifiableModel)model).getLibraryEditor(library);
  createdLibraryEditor.setProperties(libraryEditor.getProperties());
  libraryEditor.applyTo(createdLibraryEditor);
  return library;
}
 

import com.intellij.openapi.roots.libraries.LibraryType; //导入依赖的package包/类
@Nullable
public static Library createLibrary(@Nullable final LibraryType type, @NotNull final JComponent parentComponent,
                                    @NotNull final Project project, @NotNull final LibrariesModifiableModel modifiableModel) {
  final NewLibraryConfiguration configuration = createNewLibraryConfiguration(type, parentComponent, project);
  if (configuration == null) return null;
  final LibraryType<?> libraryType = configuration.getLibraryType();
  final Library library = modifiableModel.createLibrary(
    LibraryEditingUtil.suggestNewLibraryName(modifiableModel, configuration.getDefaultLibraryName()),
    libraryType != null ? libraryType.getKind() : null);

  final NewLibraryEditor editor = new NewLibraryEditor(libraryType, configuration.getProperties());
  configuration.addRoots(editor);
  final Library.ModifiableModel model = library.getModifiableModel();
  editor.applyTo((LibraryEx.ModifiableModelEx)model);
  AccessToken token = WriteAction.start();
  try {
    model.commit();
  }
  finally {
    token.finish();
  }
  return library;
}
 

import com.intellij.openapi.roots.libraries.LibraryType; //导入依赖的package包/类
public LibraryRootsComponent(@Nullable Project project, @NotNull Computable<LibraryEditor> libraryEditorComputable) {
  myProject = project;
  myLibraryEditorComputable = libraryEditorComputable;
  final LibraryEditor editor = getLibraryEditor();
  final LibraryType type = editor.getType();
  if (type != null) {
    myDescriptor = type.createLibraryRootsComponentDescriptor();
    //noinspection unchecked
    myPropertiesEditor = type.createPropertiesEditor(this);
    if (myPropertiesEditor != null) {
      myPropertiesPanel.add(myPropertiesEditor.createComponent(), BorderLayout.CENTER);
    }
  }
  if (myDescriptor == null) {
    myDescriptor = new DefaultLibraryRootsComponentDescriptor();
  }
  init(new LibraryTreeStructure(this, myDescriptor));
  updatePropertiesLabel();
  onRootsChanged();
}
 

import com.intellij.openapi.roots.libraries.LibraryType; //导入依赖的package包/类
public static void chooseTypeAndCreate(final ClasspathPanel classpathPanel,
                                       final StructureConfigurableContext context,
                                       final JButton contextButton, @NotNull final LibraryCreatedCallback callback) {
  if (LibraryEditingUtil.hasSuitableTypes(classpathPanel)) {
    final ListPopup popup = JBPopupFactory.getInstance().createListPopup(LibraryEditingUtil.createChooseTypeStep(classpathPanel, new ParameterizedRunnable<LibraryType>() {
      @Override
      public void run(LibraryType libraryType) {
        doCreateLibrary(classpathPanel, context, callback, contextButton, libraryType);
      }
    }));
    popup.showUnderneathOf(contextButton);
  }
  else {
    doCreateLibrary(classpathPanel, context, callback, contextButton, null);
  }
}
 

import com.intellij.openapi.roots.libraries.LibraryType; //导入依赖的package包/类
@NotNull
public static VirtualFile[] getLibraryRoots(@NotNull LibraryOrderEntry orderEntry) {
  Library library = orderEntry.getLibrary();
  if (library == null) return VirtualFile.EMPTY_ARRAY;
  OrderRootType[] rootTypes = LibraryType.DEFAULT_EXTERNAL_ROOT_TYPES;
  if (library instanceof LibraryEx) {
    if (((LibraryEx)library).isDisposed()) return VirtualFile.EMPTY_ARRAY;
    PersistentLibraryKind<?> libKind = ((LibraryEx)library).getKind();
    if (libKind != null) {
      rootTypes = LibraryType.findByKind(libKind).getExternalRootTypes();
    }
  }
  final ArrayList<VirtualFile> files = new ArrayList<VirtualFile>();
  for (OrderRootType rootType : rootTypes) {
    files.addAll(Arrays.asList(library.getFiles(rootType)));
  }
  return VfsUtilCore.toVirtualFileArray(files);
}
 

import com.intellij.openapi.roots.libraries.LibraryType; //导入依赖的package包/类
@Override
public Library createLibrary(@NotNull NewLibraryEditor libraryEditor,
                             @NotNull LibraryLevel level) {
  LibraryTableModifiableModelProvider provider = getProvider(level);
  if (provider == null) {
    LOG.error("cannot create module library in this context");
  }

  LibraryTableBase.ModifiableModelEx model = (LibraryTableBase.ModifiableModelEx)provider.getModifiableModel();
  final LibraryType<?> type = libraryEditor.getType();
  Library library = model.createLibrary(getUniqueLibraryName(libraryEditor.getName(), model), type == null ? null : type.getKind());
  ExistingLibraryEditor createdLibraryEditor = ((LibrariesModifiableModel)model).getLibraryEditor(library);
  createdLibraryEditor.setProperties(libraryEditor.getProperties());
  libraryEditor.applyTo(createdLibraryEditor);
  return library;
}
 

import com.intellij.openapi.roots.libraries.LibraryType; //导入依赖的package包/类
@Nullable
public static Library createLibrary(@Nullable final LibraryType type, @NotNull final JComponent parentComponent,
                                    @NotNull final Project project, @NotNull final LibrariesModifiableModel modifiableModel) {
  final NewLibraryConfiguration configuration = createNewLibraryConfiguration(type, parentComponent, project);
  if (configuration == null) return null;
  final LibraryType<?> libraryType = configuration.getLibraryType();
  final Library library = modifiableModel.createLibrary(
    LibraryEditingUtil.suggestNewLibraryName(modifiableModel, configuration.getDefaultLibraryName()), libraryType != null ? libraryType.getKind() : null);

  final NewLibraryEditor editor = new NewLibraryEditor(libraryType, configuration.getProperties());
  configuration.addRoots(editor);
  final Library.ModifiableModel model = library.getModifiableModel();
  editor.applyTo((LibraryEx.ModifiableModelEx)model);
  AccessToken token = WriteAction.start();
  try {
    model.commit();
  }
  finally {
    token.finish();
  }
  return library;
}
 

import com.intellij.openapi.roots.libraries.LibraryType; //导入依赖的package包/类
public LibraryRootsComponent(@Nullable Project project, @NotNull Computable<LibraryEditor> libraryEditorComputable) {
  myProject = project;
  myLibraryEditorComputable = libraryEditorComputable;
  final LibraryEditor editor = getLibraryEditor();
  final LibraryType type = editor.getType();
  if (type != null) {
    myDescriptor = type.createLibraryRootsComponentDescriptor();
    //noinspection unchecked
    myPropertiesEditor = type.createPropertiesEditor(this);
    if (myPropertiesEditor != null) {
      myPropertiesPanel.add(myPropertiesEditor.createComponent(), BorderLayout.CENTER);
    }
  }
  if (myDescriptor == null) {
    myDescriptor = new DefaultLibraryRootsComponentDescriptor();
  }
  init(new LibraryTreeStructure(this, myDescriptor));
  updatePropertiesLabel();
}
 

import com.intellij.openapi.roots.libraries.LibraryType; //导入依赖的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.LibraryType; //导入依赖的package包/类
@Override
public Library createLibrary(@Nonnull NewLibraryEditor libraryEditor,
                             @Nonnull LibraryLevel level) {
  LibraryTableModifiableModelProvider provider = getProvider(level);
  if (provider == null) {
    LOG.error("cannot create module library in this context");
  }

  LibraryTableBase.ModifiableModelEx model = (LibraryTableBase.ModifiableModelEx)provider.getModifiableModel();
  final LibraryType<?> type = libraryEditor.getType();
  Library library = model.createLibrary(getUniqueLibraryName(libraryEditor.getName(), model), type == null ? null : type.getKind());
  ExistingLibraryEditor createdLibraryEditor = ((LibrariesModifiableModel)model).getLibraryEditor(library);
  createdLibraryEditor.setProperties(libraryEditor.getProperties());
  libraryEditor.applyTo(createdLibraryEditor);
  return library;
}
 

import com.intellij.openapi.roots.libraries.LibraryType; //导入依赖的package包/类
@Nullable
public static Library createLibrary(@Nullable final LibraryType type,
                                    @Nonnull final JComponent parentComponent,
                                    @Nonnull final Project project,
                                    @Nonnull final LibrariesModifiableModel modifiableModel) {
  final NewLibraryConfiguration configuration = createNewLibraryConfiguration(type, parentComponent, project);
  if (configuration == null) return null;
  final LibraryType<?> libraryType = configuration.getLibraryType();
  final Library library = modifiableModel
    .createLibrary(LibraryEditingUtil.suggestNewLibraryName(modifiableModel, configuration.getDefaultLibraryName()),
                   libraryType != null ? libraryType.getKind() : null);

  final NewLibraryEditor editor = new NewLibraryEditor(libraryType, configuration.getProperties());
  configuration.addRoots(editor);
  final Library.ModifiableModel model = library.getModifiableModel();
  editor.applyTo((LibraryEx.ModifiableModelEx)model);
  AccessToken token = WriteAction.start();
  try {
    model.commit();
  }
  finally {
    token.finish();
  }
  return library;
}
 

import com.intellij.openapi.roots.libraries.LibraryType; //导入依赖的package包/类
@Nullable
public static NewLibraryConfiguration createNewLibraryConfiguration(@Nullable LibraryType type,
                                                                    @Nonnull JComponent parentComponent,
                                                                    @Nonnull Project project) {
  final NewLibraryConfiguration configuration;
  final VirtualFile baseDir = project.getBaseDir();
  if (type != null) {
    configuration = type.createNewLibrary(parentComponent, baseDir, project);
  }
  else {
    configuration = LibraryTypeService.getInstance()
      .createLibraryFromFiles(new DefaultLibraryRootsComponentDescriptor(), parentComponent, baseDir, null, project);
  }
  if (configuration == null) return null;
  return configuration;
}
 

import com.intellij.openapi.roots.libraries.LibraryType; //导入依赖的package包/类
public LibraryRootsComponent(@Nullable Project project, @Nonnull Computable<LibraryEditor> libraryEditorComputable) {
  myProject = project;
  myLibraryEditorComputable = libraryEditorComputable;
  final LibraryEditor editor = getLibraryEditor();
  final LibraryType type = editor.getType();
  if (type != null) {
    myDescriptor = type.createLibraryRootsComponentDescriptor();
    //noinspection unchecked
    myPropertiesEditor = type.createPropertiesEditor(this);
    if (myPropertiesEditor != null) {
      myPropertiesPanel.add(myPropertiesEditor.createComponent(), BorderLayout.CENTER);
    }
  }
  if (myDescriptor == null) {
    myDescriptor = new DefaultLibraryRootsComponentDescriptor();
  }
  init(new LibraryTreeStructure(this, myDescriptor));
  updatePropertiesLabel();
  onRootsChanged();
}
 

import com.intellij.openapi.roots.libraries.LibraryType; //导入依赖的package包/类
@Nonnull
static VirtualFile[] getLibraryRoots(@Nonnull LibraryOrderEntry orderEntry) {
  Library library = orderEntry.getLibrary();
  if (library == null) return VirtualFile.EMPTY_ARRAY;
  OrderRootType[] rootTypes = LibraryType.DEFAULT_EXTERNAL_ROOT_TYPES;
  if (library instanceof LibraryEx) {
    if (((LibraryEx)library).isDisposed()) return VirtualFile.EMPTY_ARRAY;
    PersistentLibraryKind<?> libKind = ((LibraryEx)library).getKind();
    if (libKind != null) {
      rootTypes = LibraryType.findByKind(libKind).getExternalRootTypes();
    }
  }
  final ArrayList<VirtualFile> files = new ArrayList<VirtualFile>();
  for (OrderRootType rootType : rootTypes) {
    files.addAll(Arrays.asList(library.getFiles(rootType)));
  }
  return VfsUtilCore.toVirtualFileArray(files);
}
 

import com.intellij.openapi.roots.libraries.LibraryType; //导入依赖的package包/类
@NotNull
private static Library createLibraryInTable(final @NotNull NewLibraryEditor editor, final LibraryTable table) {
  LibraryTable.ModifiableModel modifiableModel = table.getModifiableModel();
  final String name = StringUtil.isEmpty(editor.getName()) ? null : getUniqueLibraryName(editor.getName(), modifiableModel);
  final LibraryType<?> type = editor.getType();
  Library library = modifiableModel.createLibrary(name, type == null ? null : type.getKind());
  final LibraryEx.ModifiableModelEx model = (LibraryEx.ModifiableModelEx)library.getModifiableModel();
  editor.applyTo(model);
  model.commit();
  modifiableModel.commit();
  return library;
}