import consulo.roots.impl.ProductionContentFolderTypeProvider; //导入依赖的package包/类
private void updateCustomPathToFile() {
  if (myCustomPathCheckBox.isSelected()) {
    myPathToFileTextField.setText(FileUtil.toSystemDependentName(customPathToFile));
  }
  else if (getSelectedModule() != null) {
    final HaxeModuleSettings settings = HaxeModuleSettings.getInstance(getSelectedModule());
    final ModuleCompilerPathsManager compilerPathsManager = ModuleCompilerPathsManager.getInstance(getSelectedModule());

    final String url = compilerPathsManager.getCompilerOutputUrl(ProductionContentFolderTypeProvider.getInstance()) + "/" + settings.getOutputFileName();
    myPathToFileTextField.setText(FileUtil.toSystemDependentName(VfsUtil.urlToPath(url)));
  }
  else {
    myPathToFileTextField.setText("");
  }
  myPathToFileTextField.setEnabled(myCustomPathCheckBox.isSelected());
}
 

import consulo.roots.impl.ProductionContentFolderTypeProvider; //导入依赖的package包/类
@Nullable
private static File findFileByRelativePath(final CompileContext context, final Module module, final String relativePath)
{
	VirtualFile output = context.getOutputForFile(module, ProductionContentFolderTypeProvider.getInstance());

	File file = output != null ? getFileByRelativeOrNull(output.getPath(), relativePath) : null;
	if(file == null)
	{
		final VirtualFile testsOutput = context.getOutputForFile(module, TestContentFolderTypeProvider.getInstance());
		if(testsOutput != null && !testsOutput.equals(output))
		{
			file = getFileByRelativeOrNull(testsOutput.getPath(), relativePath);
		}
	}
	return file;
}
 

import consulo.roots.impl.ProductionContentFolderTypeProvider; //导入依赖的package包/类
public static Module addModule(final Project project, final String name, final VirtualFile root) {
  return new WriteCommandAction<Module>(project) {
    @Override
    protected void run(Result<Module> result) throws Throwable {
      final ModifiableModuleModel moduleModel = ModuleManager.getInstance(project).getModifiableModel();
      String moduleName = moduleModel.newModule(name, root.getPath()).getName();
      moduleModel.commit();

      final Module dep = ModuleManager.getInstance(project).findModuleByName(moduleName);
      final ModifiableRootModel model = ModuleRootManager.getInstance(dep).getModifiableModel();
      final ContentEntry entry = model.addContentEntry(root);
      entry.addFolder(root, ProductionContentFolderTypeProvider.getInstance());

      model.commit();
      result.setResult(dep);
    }
  }.execute().getResultObject();
}
 

import consulo.roots.impl.ProductionContentFolderTypeProvider; //导入依赖的package包/类
/**
 * @param module
 * @param forTestClasses true if directory for test sources, false - for sources.
 * @return a directory to which the sources (or test sources depending on the second partameter) should be compiled.
 *         Null is returned if output directory is not specified or is not valid
 */
@Nullable
public static VirtualFile getModuleOutputDirectory(final Module module, boolean forTestClasses) {
  final ModuleCompilerPathsManager manager = ModuleCompilerPathsManager.getInstance(module);
  VirtualFile outPath;
  if (forTestClasses) {
    final VirtualFile path = manager.getCompilerOutput(TestContentFolderTypeProvider.getInstance());
    if (path != null) {
      outPath = path;
    }
    else {
      outPath = manager.getCompilerOutput(ProductionContentFolderTypeProvider.getInstance());
    }
  }
  else {
    outPath = manager.getCompilerOutput(ProductionContentFolderTypeProvider.getInstance());
  }
  if (outPath == null) {
    return null;
  }
  if (!outPath.isValid()) {
    LOGGER.info("Requested output path for module " + module.getName() + " is not valid");
    return null;
  }
  return outPath;
}
 

import consulo.roots.impl.ProductionContentFolderTypeProvider; //导入依赖的package包/类
/**
 * The same as {@link #getModuleOutputDirectory} but returns String.
 * The method still returns a non-null value if the output path is specified in Settings but does not exist on disk.
 */
@Nullable
@Deprecated
public static String getModuleOutputPath(final Module module, final boolean forTestClasses) {
  final String outPathUrl;
  final Application application = ApplicationManager.getApplication();
  final ModuleCompilerPathsManager pathsManager = ModuleCompilerPathsManager.getInstance(module);

  if (application.isDispatchThread()) {
    outPathUrl = pathsManager.getCompilerOutputUrl(
      forTestClasses ? TestContentFolderTypeProvider.getInstance() : ProductionContentFolderTypeProvider.getInstance());
  }
  else {
    outPathUrl = application.runReadAction(new Computable<String>() {
      @Override
      public String compute() {
        return pathsManager.getCompilerOutputUrl(
          forTestClasses ? TestContentFolderTypeProvider.getInstance() : ProductionContentFolderTypeProvider.getInstance());
      }
    });
  }

  return outPathUrl != null ? VirtualFileManager.extractPath(outPathUrl) : null;
}
 

import consulo.roots.impl.ProductionContentFolderTypeProvider; //导入依赖的package包/类
@Override
public void moduleCompileOutputChanged(final String baseUrl, final String moduleName) {
  ModuleCompilerPathsManager moduleCompilerPathsManager = ModuleCompilerPathsManager.getInstance(getModule());
  if (moduleCompilerPathsManager.isInheritedCompilerOutput()) {
    if (baseUrl != null) {
      myOutputPathPanel.setText(FileUtil.toSystemDependentName(
              VfsUtilCore.urlToPath(moduleCompilerPathsManager.getCompilerOutputUrl(ProductionContentFolderTypeProvider.getInstance()))));
      myTestsOutputPathPanel.setText(FileUtil.toSystemDependentName(
              VfsUtilCore.urlToPath(moduleCompilerPathsManager.getCompilerOutputUrl(TestContentFolderTypeProvider.getInstance()))));
      myResourcesOutputPathPanel.setText(FileUtil.toSystemDependentName(
              VfsUtilCore.urlToPath(moduleCompilerPathsManager.getCompilerOutputUrl(ProductionResourceContentFolderTypeProvider.getInstance()))));
      myTestResourcesOutputPathPanel.setText(FileUtil.toSystemDependentName(
              VfsUtilCore.urlToPath(moduleCompilerPathsManager.getCompilerOutputUrl(TestResourceContentFolderTypeProvider.getInstance()))));
    }
    else {
      myOutputPathPanel.setText(null);
      myTestsOutputPathPanel.setText(null);
      myResourcesOutputPathPanel.setText(null);
      myTestResourcesOutputPathPanel.setText(null);
    }
  }
}
 

import consulo.roots.impl.ProductionContentFolderTypeProvider; //导入依赖的package包/类
public void testCreationOfSourceFolderWithFile() throws IOException {
  VirtualFile dir = root.createChildDirectory(null, "src");
  String url = dir.getUrl();

  ContentFolder f = entry.addFolder(dir, ProductionContentFolderTypeProvider.getInstance());
  assertEquals(dir, f.getFile());
  assertEquals(url, f.getUrl());

  dir.delete(null);
  assertNull(f.getFile());
  assertEquals(url, f.getUrl());

  dir = root.createChildDirectory(null, "src");
  assertEquals(dir, f.getFile());
  assertEquals(url, f.getUrl());
}
 

import consulo.roots.impl.ProductionContentFolderTypeProvider; //导入依赖的package包/类
private void replaceSourceRoot(final VirtualFile newSourceRoot) {
  ApplicationManager.getApplication().runWriteAction(
      new Runnable() {
        @Override
        public void run() {
          final ModifiableRootModel rootModel = ModuleRootManager.getInstance(myModule).getModifiableModel();
          final ContentEntry[] content = rootModel.getContentEntries();
          boolean contentToChangeFound = false;
          for (ContentEntry contentEntry : content) {
            final ContentFolder[] sourceFolders = contentEntry.getFolders(ContentFolderScopes.of(ProductionContentFolderTypeProvider.getInstance()));
            for (ContentFolder sourceFolder : sourceFolders) {
              contentEntry.removeFolder(sourceFolder);
            }
            final VirtualFile contentRoot = contentEntry.getFile();
            if (contentRoot != null && VfsUtilCore.isAncestor(contentRoot, newSourceRoot, false)) {
              contentEntry.addFolder(newSourceRoot, ProductionContentFolderTypeProvider.getInstance());
              contentToChangeFound = true;
            }
          }
          assertTrue(contentToChangeFound);
          rootModel.commit();
        }
      }
  );
}
 

import consulo.roots.impl.ProductionContentFolderTypeProvider; //导入依赖的package包/类
@Override
public void patch(@NotNull ModifiableRootModel model, @NotNull Set<ContentFolderTypeProvider> set)
{
	HaxeModuleExtension extension = model.getExtension(HaxeModuleExtension.class);
	if(extension != null)
	{
		set.add(ProductionContentFolderTypeProvider.getInstance());
	}
}
 

import consulo.roots.impl.ProductionContentFolderTypeProvider; //导入依赖的package包/类
@Override
public void patch(@NotNull ModifiableRootModel model, @NotNull Set<ContentFolderTypeProvider> set)
{
	DotNetModuleExtension extension = model.getExtension(DotNetModuleExtension.class);
	if(extension != null && extension.isAllowSourceRoots())
	{
		set.add(ProductionContentFolderTypeProvider.getInstance());
	}
}
 

import consulo.roots.impl.ProductionContentFolderTypeProvider; //导入依赖的package包/类
@NotNull
@Override
public VirtualFile[] getFiles(@NotNull ModuleRootModel moduleRootModel, @NotNull Predicate<ContentFolderTypeProvider> predicate)
{
	if(predicate.apply(ProductionContentFolderTypeProvider.getInstance()))
	{
		return moduleRootModel.getContentRoots();
	}
	return VirtualFile.EMPTY_ARRAY;
}
 

import consulo.roots.impl.ProductionContentFolderTypeProvider; //导入依赖的package包/类
@NotNull
@Override
public String[] getUrls(@NotNull ModuleRootModel moduleRootModel, @NotNull Predicate<ContentFolderTypeProvider> predicate)
{
	if(predicate.apply(ProductionContentFolderTypeProvider.getInstance()))
	{
		return moduleRootModel.getContentRootUrls();
	}
	return ArrayUtil.EMPTY_STRING_ARRAY;
}
 

import consulo.roots.impl.ProductionContentFolderTypeProvider; //导入依赖的package包/类
public static void addSourceContentToRoots(final Module module, @Nonnull final VirtualFile vDir, final boolean testSource) {
  new WriteCommandAction.Simple(module.getProject()) {
    @Override
    protected void run() throws Throwable {
      final ModuleRootManager rootManager = ModuleRootManager.getInstance(module);
      final ModifiableRootModel rootModel = rootManager.getModifiableModel();
      final ContentEntry contentEntry = rootModel.addContentEntry(vDir);
      contentEntry.addFolder(vDir, testSource ? TestContentFolderTypeProvider.getInstance() : ProductionContentFolderTypeProvider.getInstance());
      rootModel.commit();
    }
  }.execute().throwException();
}
 

import consulo.roots.impl.ProductionContentFolderTypeProvider; //导入依赖的package包/类
public static void addSourceRoot(final Module module, final VirtualFile vDir, final boolean isTestSource) {
  new WriteCommandAction.Simple(module.getProject()) {
    @Override
    protected void run() throws Throwable {
      final ModuleRootManager rootManager = ModuleRootManager.getInstance(module);
      final ModifiableRootModel rootModel = rootManager.getModifiableModel();
      ContentEntry entry = findContentEntry(rootModel, vDir);
      if (entry == null) entry = rootModel.addContentEntry(vDir);
      entry.addFolder(vDir, isTestSource ? TestContentFolderTypeProvider.getInstance() : ProductionContentFolderTypeProvider.getInstance());
      rootModel.commit();
    }
  }.execute().throwException();
}
 

import consulo.roots.impl.ProductionContentFolderTypeProvider; //导入依赖的package包/类
@Override
public VirtualFile getModuleOutputDirectory(final Module module) {
  return ApplicationManager.getApplication().runReadAction(new Computable<VirtualFile>() {
    @Override
    public VirtualFile compute() {
      return ModuleCompilerPathsManager.getInstance(module)
        .getCompilerOutput(ProductionContentFolderTypeProvider.getInstance());
    }
  });
}
 

import consulo.roots.impl.ProductionContentFolderTypeProvider; //导入依赖的package包/类
private TIntObjectHashMap<Pair<Integer, Integer>> buildOutputRootsLayout(ProjectRef projRef) {
  final TIntObjectHashMap<Pair<Integer, Integer>> map = new TIntObjectHashMap<Pair<Integer, Integer>>();
  for (Module module : ModuleManager.getInstance(projRef.get()).getModules()) {
    ModuleCompilerPathsManager moduleCompilerPathsManager = ModuleCompilerPathsManager.getInstance(module);

    final VirtualFile output = moduleCompilerPathsManager.getCompilerOutput(ProductionContentFolderTypeProvider.getInstance());
    final int first = output != null ? Math.abs(getFileId(output)) : -1;
    final VirtualFile testsOutput = moduleCompilerPathsManager.getCompilerOutput(TestContentFolderTypeProvider.getInstance());
    final int second = testsOutput != null ? Math.abs(getFileId(testsOutput)) : -1;
    map.put(getModuleId(module), new Pair<Integer, Integer>(first, second));
  }
  return map;
}
 

import consulo.roots.impl.ProductionContentFolderTypeProvider; //导入依赖的package包/类
@Override
public void recalculateOutputDirs() {
  final Module[] allModules = ModuleManager.getInstance(myProject).getModules();

  final Set<VirtualFile> allDirs = new OrderedSet<VirtualFile>();
  final Set<VirtualFile> testOutputDirs = new java.util.HashSet<VirtualFile>();
  final Set<VirtualFile> productionOutputDirs = new java.util.HashSet<VirtualFile>();

  for (Module module : allModules) {
    ModuleCompilerPathsManager moduleCompilerPathsManager = ModuleCompilerPathsManager.getInstance(module);

    final VirtualFile output = moduleCompilerPathsManager.getCompilerOutput(ProductionContentFolderTypeProvider.getInstance());
    if (output != null && output.isValid()) {
      allDirs.add(output);
      productionOutputDirs.add(output);
    }

    final VirtualFile testsOutput = moduleCompilerPathsManager.getCompilerOutput(TestContentFolderTypeProvider.getInstance());
    if (testsOutput != null && testsOutput.isValid()) {
      allDirs.add(testsOutput);
      testOutputDirs.add(testsOutput);
    }
  }
  myOutputDirectories = VfsUtil.toVirtualFileArray(allDirs);
  // need this to ensure that the sent contains only _dedicated_ test output dirs
  // Directories that are configured for both test and production classes must not be added in the resulting set
  testOutputDirs.removeAll(productionOutputDirs);
  myTestOutputDirectories = Collections.unmodifiableSet(testOutputDirs);
}
 

import consulo.roots.impl.ProductionContentFolderTypeProvider; //导入依赖的package包/类
@Override
public VirtualFile getOutputForFile(Module module, VirtualFile virtualFile) {
  ContentFolderTypeProvider contentFolderTypeForFile = myProjectFileIndex.getContentFolderTypeForFile(virtualFile);
  if (contentFolderTypeForFile == null) {
    contentFolderTypeForFile = ProductionContentFolderTypeProvider.getInstance();
  }

  return getOutputForFile(module, contentFolderTypeForFile);
}
 

import consulo.roots.impl.ProductionContentFolderTypeProvider; //导入依赖的package包/类
private static void syncPaths(@Nonnull Module module, @Nonnull ModuleData data) {
  ModuleCompilerPathsManager compilerPathsManager = ModuleCompilerPathsManager.getInstance(module);
  compilerPathsManager.setInheritedCompilerOutput(data.isInheritProjectCompileOutputPath());
  if (!data.isInheritProjectCompileOutputPath()) {
    String compileOutputPath = data.getCompileOutputPath(ExternalSystemSourceType.SOURCE);
    if (compileOutputPath != null) {
      compilerPathsManager.setCompilerOutputUrl(ProductionContentFolderTypeProvider.getInstance(), VfsUtilCore.pathToUrl(compileOutputPath));
    }
    String testCompileOutputPath = data.getCompileOutputPath(ExternalSystemSourceType.TEST);
    if (testCompileOutputPath != null) {
      compilerPathsManager.setCompilerOutputUrl(TestContentFolderTypeProvider.getInstance(), VfsUtilCore.pathToUrl(testCompileOutputPath));
    }
  }
}
 

import consulo.roots.impl.ProductionContentFolderTypeProvider; //导入依赖的package包/类
private CommitableFieldPanel toField(ContentFolderTypeProvider contentFolderTypeProvider) {
  if (contentFolderTypeProvider == ProductionContentFolderTypeProvider.getInstance()) {
    return myOutputPathPanel;
  }
  else if (contentFolderTypeProvider == ProductionResourceContentFolderTypeProvider.getInstance()) {
    return myResourcesOutputPathPanel;
  }
  else if (contentFolderTypeProvider == TestContentFolderTypeProvider.getInstance()) {
    return myTestsOutputPathPanel;
  }
  else if (contentFolderTypeProvider == TestResourceContentFolderTypeProvider.getInstance()) {
    return myTestResourcesOutputPathPanel;
  }
  throw new IllegalArgumentException(contentFolderTypeProvider.getId());
}