Java Facet类代码示例

import com.intellij.facet.Facet; //导入依赖的package包/类
@Override
public boolean remove(@NotNull Collection<Module> modules) {
  ModulesConfigurator modulesConfigurator = myContext.myModulesConfigurator;
  List<Module> deleted = modulesConfigurator.deleteModules(modules);
  if (deleted.isEmpty()) {
    return false;
  }
  for (Module module : deleted) {
    List<Facet> removed = modulesConfigurator.getFacetsConfigurator().removeAllFacets(module);
    FacetStructureConfigurable.getInstance(myProject).removeFacetNodes(removed);
    myContext.getDaemonAnalyzer().removeElement(new ModuleProjectStructureElement(myContext, module));

    for (final ModuleStructureExtension extension : ModuleStructureExtension.EP_NAME.getExtensions()) {
      extension.moduleRemoved(module);
    }
  }
  return true;
}
 

import com.intellij.facet.Facet; //导入依赖的package包/类
public static boolean showFacetSettingsDialog(@NotNull final Facet facet,
                                              @Nullable final String tabNameToSelect) {
  final Project project = facet.getModule().getProject();
  final ProjectStructureConfigurable config = ProjectStructureConfigurable.getInstance(project);
  return ShowSettingsUtil.getInstance().editConfigurable(project, config, new Runnable() {
    @Override
    public void run() {
      final ModuleStructureConfigurable modulesConfig = config.getModulesConfig();
      config.select(facet, true).doWhenDone(new Runnable() {
        @Override
        public void run() {
          if (tabNameToSelect != null) {
            FacetEditorImpl facetEditor = modulesConfig.getFacetConfigurator().getOrCreateEditor(facet);
            facetEditor.setSelectedTabName(tabNameToSelect);
          }
        }
      });
    }
  });
}
 

import com.intellij.facet.Facet; //导入依赖的package包/类
private static void addRootsFromModule(Module module, Collection<String> pythonPathList) {

    // for Jython
    final CompilerModuleExtension extension = CompilerModuleExtension.getInstance(module);
    if (extension != null) {
      final VirtualFile path = extension.getCompilerOutputPath();
      if (path != null) {
        pythonPathList.add(path.getPath());
      }
      final VirtualFile pathForTests = extension.getCompilerOutputPathForTests();
      if (pathForTests != null) {
        pythonPathList.add(pathForTests.getPath());
      }
    }

    //additional paths from facets (f.e. buildout)
    final Facet[] facets = FacetManager.getInstance(module).getAllFacets();
    for (Facet facet : facets) {
      if (facet instanceof PythonPathContributingFacet) {
        List<String> more_paths = ((PythonPathContributingFacet)facet).getAdditionalPythonPath();
        if (more_paths != null) pythonPathList.addAll(more_paths);
      }
    }
  }
 

import com.intellij.facet.Facet; //导入依赖的package包/类
@Nullable
private MultipleFacetSettingsEditor createAllFacetsEditor() {
  ProjectFacetsConfigurator facetsConfigurator = myContext.myModulesConfigurator.getFacetsConfigurator();
  List<Facet> facets = new ArrayList<Facet>();
  for (Module module : myContext.getModules()) {
    facets.addAll(facetsConfigurator.getFacetsByType(module, myFacetType.getId()));
  }
  if (!facets.isEmpty()) {
    final FacetEditor[] editors = new FacetEditor[facets.size()];
    for (int i = 0; i < facets.size(); i++) {
      editors[i] = facetsConfigurator.getOrCreateEditor(facets.get(i));
    }
    return myFacetType.createMultipleConfigurationsEditor(myProject, editors);
  }
  return null;
}
 

import com.intellij.facet.Facet; //导入依赖的package包/类
public BuildoutFacet(@NotNull final FacetType facetType,
                     @NotNull final Module module,
                     @NotNull final String name,
                     @NotNull final BuildoutFacetConfiguration configuration, Facet underlyingFacet) {
  super(facetType, module, name, configuration, underlyingFacet);

  VirtualFileManager.getInstance().addVirtualFileListener(new VirtualFileAdapter() {
    @Override
    public void contentsChanged(@NotNull VirtualFileEvent event) {
      if (Comparing.equal(event.getFile(), getScript())) {
        updatePaths();
        attachLibrary(module);
      }
    }
  }, this);
}
 

import com.intellij.facet.Facet; //导入依赖的package包/类
@Override
@NotNull
public Facet[] getSortedFacets() {
  if (mySortedFacets == null) {
    final Facet[] allFacets = getAllFacets();
    if (allFacets.length == 0) {
      mySortedFacets = Facet.EMPTY_ARRAY;
    }
    else {
      LinkedHashSet<Facet> facets = new LinkedHashSet<Facet>();
      for (Facet facet : allFacets) {
        addUnderlyingFacets(facets, facet);
      }
      mySortedFacets = facets.toArray(new Facet[facets.size()]);
    }
  }
  return mySortedFacets;
}
 

import com.intellij.facet.Facet; //导入依赖的package包/类
public void setMuleFacet(Module module) {
    MuleFacetType type = (MuleFacetType)FacetTypeRegistry.getInstance().findFacetType(MuleFacet.ID);
    MuleFacetConfiguration configuration = type.createDefaultConfiguration();
    configuration.setPathToSdk(MuleSdkManager.getInstance().findFromVersion(muleVersion).getMuleHome());
    Facet facet = type.createFacet(module, type.getPresentableName(), configuration, null);
    ModifiableFacetModel model = FacetManager.getInstance(module).createModifiableModel();
    model.addFacet(facet);
    model.commit();
}
 

import com.intellij.facet.Facet; //导入依赖的package包/类
public MuleFacet(FacetType facetType,
                 Module module,
                 String name,
                 MuleFacetConfiguration configuration,
                 Facet underlyingFacet) {
    super(facetType, module, name, configuration, underlyingFacet);
}
 

import com.intellij.facet.Facet; //导入依赖的package包/类
public static Sdk findLuaSdk(Module module) {
    if (module == null) return null;
    final Sdk sdk = ModuleRootManager.getInstance(module).getSdk();
    if (sdk != null && sdk.getSdkType() instanceof LuaSdkType) return sdk;
    final Facet[] facets = FacetManager.getInstance(module).getAllFacets();
    for (Facet facet : facets) {
        final FacetConfiguration configuration = facet.getConfiguration();
        if (configuration instanceof LuaFacetConfiguration) {
            return ((LuaFacetConfiguration)configuration).getSdk();
        }
    }
    return null;
}
 

import com.intellij.facet.Facet; //导入依赖的package包/类
public void actionPerformed(AnActionEvent event) {
    Project project = event.getData(PlatformDataKeys.PROJECT);
    String pluginName = project.getName();
    String sourceRootsList = "";
    VirtualFile[] VFiles = ProjectRootManager.getInstance(project).getContentSourceRoots();
    for (int i = 0; i <= VFiles.length - 1; i++) {
        sourceRootsList += VFiles[i].getUrl() + "\n";

    }
    //System.out.println("sourceRootsList"+sourceRootsList);
    //   Messages.showInfoMessage("Source roots for the " + pluginName + " plugin:\n" + sourceRootsList, "Project Properties");


    Module[] allModules = ModuleManager.getInstance(project).getModules();
    String modulesList = "List of modules and module files in the " + project.getName() + " plugin:\n\n";
    for (int i = 0; i <= allModules.length - 1; i++) {
        modulesList += allModules[i].getName() + " " + allModules[i].getModuleFilePath() + "\n";
    }
    //System.out.println("modulesList"+modulesList);



    // Get a list of all modules the specified project includes
    String facetsList = "List of facets for modules in the " + project.getName() + " plugin:\n\n";
    for (int i = 0; i <= allModules.length - 1; i++) {
        // Get a list of all facets the module allModules[i] includes
        Facet[] facets = DefaultFacetsProvider.INSTANCE.getAllFacets(allModules[i]);
        facetsList += "Facets in the " + allModules[i].getName() + " module:\n";
        for (int j=0; j<= facets.length-1; j++){
            facetsList += facets[j].getName() + "\n";


        }


    }

    //System.out.println("facetsList"+facetsList);

}
 

import com.intellij.facet.Facet; //导入依赖的package包/类
public ActionCallback select(@Nullable final Facet facetToSelect, final boolean requestFocus) {
  Place place = createModulesPlace();
  if (facetToSelect != null) {
    place = place.putPath(ModuleStructureConfigurable.TREE_OBJECT, facetToSelect);
  }
  return navigateTo(place, requestFocus);
}
 

import com.intellij.facet.Facet; //导入依赖的package包/类
@NotNull
@Override
public AndroidGradleFacet createFacet(@NotNull Module module,
                                      @NotNull String name,
                                      @NotNull AndroidGradleFacetConfiguration configuration,
                                      @Nullable Facet underlyingFacet) {
  return new AndroidGradleFacet(module, name, configuration);
}
 

import com.intellij.facet.Facet; //导入依赖的package包/类
protected void removeFacetNodes(@NotNull List<Facet> facets) {
  for (Facet facet : facets) {
    MyNode node = findNodeByObject(myRoot, facet);
    if (node != null) {
      removePaths(TreeUtil.getPathFromRoot(node));
    }
  }
}
 

import com.intellij.facet.Facet; //导入依赖的package包/类
@Nullable
public static ProjectStructureElement getProjectStructureElementFor(PackagingElement<?> packagingElement,
                                                                     final StructureConfigurableContext context,
                                                                     final ArtifactsStructureConfigurableContext artifactsStructureContext) {
  if (packagingElement instanceof ModuleOutputPackagingElement) {
    final Module module = ((ModuleOutputPackagingElement)packagingElement).findModule(artifactsStructureContext);
    if (module != null) {
      return new ModuleProjectStructureElement(context, module);
    }
  }
  else if (packagingElement instanceof LibraryPackagingElement) {
    final Library library = ((LibraryPackagingElement)packagingElement).findLibrary(artifactsStructureContext);
    if (library != null) {
      return new LibraryProjectStructureElement(context, library);
    }
  }
  else if (packagingElement instanceof ArtifactPackagingElement) {
    final Artifact usedArtifact = ((ArtifactPackagingElement)packagingElement).findArtifact(artifactsStructureContext);
    if (usedArtifact != null) {
      return artifactsStructureContext.getOrCreateArtifactElement(usedArtifact);
    }
  }
  else if (packagingElement instanceof FacetBasedPackagingElement) {
    Facet facet = ((FacetBasedPackagingElement)packagingElement).findFacet(artifactsStructureContext);
    if (facet != null) {
      return new FacetProjectStructureElement(context, facet);
    }
  }
  return null;
}
 

import com.intellij.facet.Facet; //导入依赖的package包/类
public ProjectConfigurableContext(final @NotNull Facet facet, final boolean isNewFacet,
                                  @Nullable FacetEditorContext parentContext,
                                  final ModuleConfigurationState state, final UserDataHolder sharedModuleData,
                                  final UserDataHolder sharedProjectData) {
  super(facet, parentContext, state.getFacetsProvider(), state.getModulesProvider(), sharedModuleData, sharedProjectData);
  myModuleConfigurationState = state;
  myNewFacet = isNewFacet;
  myModule = facet.getModule();
}