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);
                           }
                         }
                       });
             }
           });
 }
  public JComponent createComponentImpl() {
    myPanel = new ClasspathPanelImpl(getState());

    myPanel.addListener(
        new OrderPanelListener() {
          public void entryMoved() {
            flushChangesToModel();
          }
        });

    final JPanel panel = new JPanel(new BorderLayout());
    panel.setBorder(BorderFactory.createEmptyBorder(6, 6, 6, 6));
    panel.add(myPanel, BorderLayout.CENTER);

    final ModuleJdkConfigurable jdkConfigurable =
        new ModuleJdkConfigurable(
            this, ProjectStructureConfigurable.getInstance(myProject).getProjectJdksModel()) {
          @Override
          protected ModifiableRootModel getRootModel() {
            return getState().getRootModel();
          }
        };
    panel.add(jdkConfigurable.createComponent(), BorderLayout.NORTH);
    jdkConfigurable.reset();
    registerDisposable(jdkConfigurable);

    List<ClasspathStorageProvider> providers = ClasspathStorage.getProviders();
    if (providers.size() > 1) {
      myClasspathFormatPanel = new ClasspathFormatPanel(providers);
      panel.add(myClasspathFormatPanel, BorderLayout.SOUTH);
    }

    return panel;
  }
 @Nullable
 public List<Module> addModule(Component parent, boolean anImport) {
   if (myProject.isDefault()) return null;
   final ProjectBuilder builder = runModuleWizard(parent, anImport);
   if (builder != null) {
     final List<Module> modules = new ArrayList<Module>();
     final List<Module> commitedModules;
     if (builder instanceof ProjectImportBuilder<?>) {
       final ModifiableArtifactModel artifactModel =
           ProjectStructureConfigurable.getInstance(myProject)
               .getArtifactsStructureConfigurable()
               .getModifiableArtifactModel();
       commitedModules =
           ((ProjectImportBuilder<?>) builder)
               .commit(myProject, myModuleModel, this, artifactModel);
     } else {
       commitedModules = builder.commit(myProject, myModuleModel, this);
     }
     if (commitedModules != null) {
       modules.addAll(commitedModules);
     }
     ApplicationManager.getApplication()
         .runWriteAction(
             new Runnable() {
               @Override
               public void run() {
                 for (Module module : modules) {
                   getOrCreateModuleEditor(module);
                 }
               }
             });
     return modules;
   }
   return null;
 }
 public void moduleRenamed(Module module, final String oldName, final String name) {
   ModuleEditor moduleEditor = myModuleEditors.get(module);
   if (moduleEditor != null) {
     moduleEditor.setModuleName(name);
     moduleEditor.updateCompilerOutputPathChanged(
         ProjectStructureConfigurable.getInstance(myProject)
             .getProjectConfig()
             .getCompilerOutputUrl(),
         name);
     myContext
         .getDaemonAnalyzer()
         .queueUpdate(new ModuleProjectStructureElement(myContext, module));
   }
 }
 public static boolean showArtifactSettings(
     @NotNull Project project, @Nullable final Artifact artifact) {
   final ProjectStructureConfigurable configurable =
       ProjectStructureConfigurable.getInstance(project);
   return ShowSettingsUtil.getInstance()
       .editConfigurable(
           project,
           configurable,
           new Runnable() {
             @Override
             public void run() {
               configurable.select(artifact, true);
             }
           });
 }
 public static boolean showDialog(
     Project project,
     @Nullable final String moduleToSelect,
     @Nullable final String editorNameToSelect) {
   final ProjectStructureConfigurable config = ProjectStructureConfigurable.getInstance(project);
   return ShowSettingsUtil.getInstance()
       .editConfigurable(
           project,
           config,
           new Runnable() {
             @Override
             public void run() {
               config.select(moduleToSelect, editorNameToSelect, true);
             }
           });
 }
  public void apply() throws ConfigurationException {
    // validate content and source roots
    final Map<VirtualFile, String> contentRootToModuleNameMap = new HashMap<VirtualFile, String>();
    final Map<VirtualFile, VirtualFile> srcRootsToContentRootMap =
        new HashMap<VirtualFile, VirtualFile>();
    for (final ModuleEditor moduleEditor : myModuleEditors.values()) {
      final ModifiableRootModel rootModel = moduleEditor.getModifiableRootModel();
      final ContentEntry[] contents = rootModel.getContentEntries();
      for (ContentEntry contentEntry : contents) {
        final VirtualFile contentRoot = contentEntry.getFile();
        if (contentRoot == null) {
          continue;
        }
        final String moduleName = moduleEditor.getName();
        final String previousName = contentRootToModuleNameMap.put(contentRoot, moduleName);
        if (previousName != null && !previousName.equals(moduleName)) {
          throw new ConfigurationException(
              ProjectBundle.message(
                  "module.paths.validation.duplicate.content.error",
                  contentRoot.getPresentableUrl(),
                  previousName,
                  moduleName));
        }
        for (VirtualFile srcRoot : contentEntry.getSourceFolderFiles()) {
          final VirtualFile anotherContentRoot = srcRootsToContentRootMap.put(srcRoot, contentRoot);
          if (anotherContentRoot != null) {
            final String problematicModule;
            final String correctModule;
            if (VfsUtilCore.isAncestor(anotherContentRoot, contentRoot, true)) {
              problematicModule = contentRootToModuleNameMap.get(anotherContentRoot);
              correctModule = contentRootToModuleNameMap.get(contentRoot);
            } else {
              problematicModule = contentRootToModuleNameMap.get(contentRoot);
              correctModule = contentRootToModuleNameMap.get(anotherContentRoot);
            }
            throw new ConfigurationException(
                ProjectBundle.message(
                    "module.paths.validation.duplicate.source.root.error",
                    problematicModule,
                    srcRoot.getPresentableUrl(),
                    correctModule));
          }
        }
      }
    }
    // additional validation: directories marked as src roots must belong to the same module as
    // their corresponding content root
    for (Map.Entry<VirtualFile, VirtualFile> entry : srcRootsToContentRootMap.entrySet()) {
      final VirtualFile srcRoot = entry.getKey();
      final VirtualFile correspondingContent = entry.getValue();
      final String expectedModuleName = contentRootToModuleNameMap.get(correspondingContent);

      for (VirtualFile candidateContent = srcRoot;
          candidateContent != null && !candidateContent.equals(correspondingContent);
          candidateContent = candidateContent.getParent()) {
        final String moduleName = contentRootToModuleNameMap.get(candidateContent);
        if (moduleName != null && !moduleName.equals(expectedModuleName)) {
          throw new ConfigurationException(
              ProjectBundle.message(
                  "module.paths.validation.source.root.belongs.to.another.module.error",
                  srcRoot.getPresentableUrl(),
                  expectedModuleName,
                  moduleName));
        }
      }
    }

    final List<ModifiableRootModel> models =
        new ArrayList<ModifiableRootModel>(myModuleEditors.size());
    for (ModuleEditor moduleEditor : myModuleEditors.values()) {
      moduleEditor.canApply();
    }

    final Map<Sdk, Sdk> modifiedToOriginalMap = new HashMap<Sdk, Sdk>();
    final ProjectSdksModel projectJdksModel =
        ProjectStructureConfigurable.getInstance(myProject).getProjectJdksModel();
    for (Map.Entry<Sdk, Sdk> entry : projectJdksModel.getProjectSdks().entrySet()) {
      modifiedToOriginalMap.put(entry.getValue(), entry.getKey());
    }

    final Ref<ConfigurationException> exceptionRef = Ref.create();
    DumbService.getInstance(myProject)
        .allowStartingDumbModeInside(
            DumbModePermission.MAY_START_BACKGROUND,
            new Runnable() {
              public void run() {
                ApplicationManager.getApplication()
                    .runWriteAction(
                        new Runnable() {
                          @Override
                          public void run() {
                            try {
                              for (final ModuleEditor moduleEditor : myModuleEditors.values()) {
                                final ModifiableRootModel model = moduleEditor.apply();
                                if (model != null) {
                                  if (!model.isSdkInherited()) {
                                    // make sure the sdk is set to original SDK stored in the JDK
                                    // Table
                                    final Sdk modelSdk = model.getSdk();
                                    if (modelSdk != null) {
                                      final Sdk original = modifiedToOriginalMap.get(modelSdk);
                                      if (original != null) {
                                        model.setSdk(original);
                                      }
                                    }
                                  }
                                  models.add(model);
                                }
                              }
                              myFacetsConfigurator.applyEditors();
                            } catch (ConfigurationException e) {
                              exceptionRef.set(e);
                              return;
                            }

                            try {
                              final ModifiableRootModel[] rootModels =
                                  models.toArray(new ModifiableRootModel[models.size()]);
                              ModifiableModelCommitter.multiCommit(rootModels, myModuleModel);
                              myModuleModelCommitted = true;
                              myFacetsConfigurator.commitFacets();

                            } finally {
                              ModuleStructureConfigurable.getInstance(myProject)
                                  .getFacetEditorFacade()
                                  .clearMaps(false);

                              myFacetsConfigurator = createFacetsConfigurator();
                              myModuleModel =
                                  ModuleManager.getInstance(myProject).getModifiableModel();
                              myModuleModelCommitted = false;
                            }
                          }
                        });
              }
            });

    if (!exceptionRef.isNull()) {
      throw exceptionRef.get();
    }

    myModified = false;
  }