Java Code Examples for com.intellij.openapi.roots.OrderRootType#getAllTypes()

@Nonnull
@Override
protected JComponent createCenterComponent() {
  myTabbedPane = new TabbedPaneWrapper(myDisposable);
  for (OrderRootType type : OrderRootType.getAllTypes()) {
    if (showTabForType(type)) {
      final OrderRootTypeUIFactory factory = OrderRootTypeUIFactory.FACTORY.getByKey(type);
      if(factory == null) {
        continue;
      }

      SdkPathEditor pathEditor = getPathEditor(type);

      myTabbedPane.addTab(pathEditor.getDisplayName(), pathEditor.createComponent());
    }
  }

  myTabbedPane.addChangeListener(new ChangeListener() {
    @Override
    public void stateChanged(final ChangeEvent e) {
      myHistory.pushQueryPlace();
    }
  });
  return myTabbedPane.getComponent();
}
 

@Override
@Nullable
public VirtualFile getExistingRootDirectory() {
  for (OrderRootType orderRootType : OrderRootType.getAllTypes()) {
    final VirtualFile[] existingRoots = getLibraryEditor().getFiles(orderRootType);
    if (existingRoots.length > 0) {
      VirtualFile existingRoot = existingRoots[0];
      if (existingRoot.getFileSystem() instanceof ArchiveFileSystem) {
        existingRoot = ((ArchiveFileSystem)existingRoot.getFileSystem()).getLocalVirtualFileFor(existingRoot);
      }
      if (existingRoot != null) {
        if (existingRoot.isDirectory()) {
          return existingRoot;
        }
        else {
          return existingRoot.getParent();
        }
      }
    }
  }
  return null;
}
 

private Set<VirtualFile> getNotExcludedRoots() {
  Set<VirtualFile> roots = new LinkedHashSet<VirtualFile>();
  String[] excludedRootUrls = getLibraryEditor().getExcludedRootUrls();
  Set<VirtualFile> excludedRoots = new HashSet<VirtualFile>();
  for (String url : excludedRootUrls) {
    ContainerUtil.addIfNotNull(excludedRoots, VirtualFileManager.getInstance().findFileByUrl(url));
  }
  for (OrderRootType type : OrderRootType.getAllTypes()) {
    VirtualFile[] files = getLibraryEditor().getFiles(type);
    for (VirtualFile file : files) {
      if (!VfsUtilCore.isUnder(file, excludedRoots)) {
        roots.add(PathUtil.getLocalFile(file));
      }
    }
  }
  return roots;
}
 

private void addRootsFromModules(boolean includeSourceRoots, Set<String> recursive, Set<String> flat) {
  final Module[] modules = ModuleManager.getInstance(myProject).getModules();
  for (Module module : modules) {
    final ModuleRootManager moduleRootManager = ModuleRootManager.getInstance(module);

    addRootsToTrack(moduleRootManager.getContentRootUrls(), recursive, flat);

    if (includeSourceRoots) {
      addRootsToTrack(moduleRootManager.getContentFolderUrls(ContentFolderScopes.all(false)), recursive, flat);
    }

    final OrderEntry[] orderEntries = moduleRootManager.getOrderEntries();
    for (OrderEntry entry : orderEntries) {
      if (entry instanceof OrderEntryWithTracking) {
        for (OrderRootType orderRootType : OrderRootType.getAllTypes()) {
          addRootsToTrack(entry.getUrls(orderRootType), recursive, flat);
        }
      }
    }
  }
}
 

public void readExternal(@Nonnull Element element) {
  for (OrderRootType type : OrderRootType.getAllTypes()) {
    read(element, type);
  }

  ApplicationManager.getApplication().runReadAction(() -> myRoots.values().forEach(container -> {
    if (myNoCopyJars) {
      for (String root : container.getUrls()) {
        setNoCopyJars(root);
      }
    }
  }));
}
 

void copyRootsFrom(@Nonnull RootProvider rootContainer) {
  removeAllRoots();
  for (OrderRootType rootType : OrderRootType.getAllTypes()) {
    final String[] newRoots = rootContainer.getUrls(rootType);
    for (String newRoot : newRoots) {
      addRoot(newRoot, rootType);
    }
  }
}
 

@Nonnull
private static OrderRootType getJarDirectoryRootType(@Nullable String type) {
  for (OrderRootType rootType : OrderRootType.getAllTypes()) {
    if (rootType.name().equals(type)) {
      return rootType;
    }
  }
  return DEFAULT_JAR_DIRECTORY_TYPE;
}
 

private void createMainPanel() {
  myMainPanel = new JPanel(new GridBagLayout());

  for (OrderRootType type : OrderRootType.getAllTypes()) {
    if (showTabForType(type)) {
      final OrderRootTypeUIFactory factory = OrderRootTypeUIFactory.FACTORY.getByKey(type);
      if(factory == null) {
        LOGGER.error("OrderRootTypeUIFactory is not defined for order root type: " + type);
        continue;
      }
      final SdkPathEditor pathEditor = factory.createPathEditor(mySdk);
      if (pathEditor != null) {
        pathEditor.setAddBaseDir(mySdk.getHomeDirectory());
        myPathEditors.put(type, pathEditor);
      }
    }
  }

  JComponent centerComponent = createCenterComponent();

  myHomeComponent = createHomeComponent();
  myHomeComponent.getTextField().setEditable(false);
  myHomeComponent.getButton().setVisible(!mySdk.isPredefined() && ((SdkType)mySdk.getSdkType()).supportsUserAdd());

  myHomeFieldLabel = new JLabel(getHomeFieldLabelValue());
  myMainPanel.add(myHomeFieldLabel,
                  new GridBagConstraints(0, GridBagConstraints.RELATIVE, 1, 1, 0.0, 0.0, GridBagConstraints.WEST, GridBagConstraints.NONE,
                                         new Insets(2, 10, 2, 2), 0, 0));
  myMainPanel.add(myHomeComponent, new GridBagConstraints(1, GridBagConstraints.RELATIVE, 1, 1, 1.0, 0.0, GridBagConstraints.CENTER,
                                                          GridBagConstraints.HORIZONTAL, new Insets(2, 2, 2, 10), 0, 0));

  myAdditionalDataPanel = new JPanel(new BorderLayout());
  myMainPanel.add(myAdditionalDataPanel, new GridBagConstraints(0, GridBagConstraints.RELATIVE, 2, 1, 1.0, 0.0, GridBagConstraints.CENTER,
                                                                GridBagConstraints.BOTH, new Insets(2, 0, 0, 0), 0, 0));

  myMainPanel.add(centerComponent,
                  new GridBagConstraints(0, GridBagConstraints.RELATIVE, 2, 1, 1.0, 1.0, GridBagConstraints.CENTER,
                                         GridBagConstraints.BOTH, new Insets(2, 0, 0, 0), 0, 0));
}
 

public static void copyLibrary(LibraryEx from, Map<String, String> rootMapping, LibraryEx.ModifiableModelEx target) {
  target.setProperties(from.getProperties());
  for (OrderRootType type : OrderRootType.getAllTypes()) {
    final String[] urls = from.getUrls(type);
    for (String url : urls) {
      final String protocol = VirtualFileManager.extractProtocol(url);
      if (protocol == null) continue;
      final String fullPath = VirtualFileManager.extractPath(url);
      final int sep = fullPath.indexOf(ArchiveFileSystem.ARCHIVE_SEPARATOR);
      String localPath;
      String pathInJar;
      if (sep != -1) {
        localPath = fullPath.substring(0, sep);
        pathInJar = fullPath.substring(sep);
      }
      else {
        localPath = fullPath;
        pathInJar = "";
      }
      final String targetPath = rootMapping.get(localPath);
      String targetUrl = targetPath != null ? VirtualFileManager.constructUrl(protocol, targetPath + pathInJar) : url;

      if (from.isJarDirectory(url, type)) {
        target.addJarDirectory(targetUrl, false, type);
      }
      else {
        target.addRoot(targetUrl, type);
      }
    }
  }
}
 

@Nonnull
private Collection<OrderRootType> getAllRootTypes() {
  return OrderRootType.getAllTypes();
}
 

/**
 * @return Array of root types supported by a library type associated with the roots
 *         component descriptor. All persistent root types are returned by default. 
 */
@Nonnull
public List<OrderRootType> getRootTypes() {
  return OrderRootType.getAllTypes();
}
 

@Override
public Collection<OrderRootType> getOrderRootTypes() {
  return OrderRootType.getAllTypes();
}
 

private static boolean orderEntryContainsFile(OrderEntry orderEntry, VirtualFile file) {
  for (OrderRootType rootType : OrderRootType.getAllTypes()) {
    if (containsFileInOrderType(orderEntry, rootType, file)) return true;
  }
  return false;
}