@Override public void navigate(boolean openLibraryEditor) { final OrderEntry entry = getSelectedEntry(); final ProjectStructureConfigurable rootConfigurable = ProjectStructureConfigurable.getInstance(myState.getProject()); if (entry instanceof ModuleOrderEntry) { Module module = ((ModuleOrderEntry) entry).getModule(); if (module != null) { rootConfigurable.select(module.getName(), null, true); } } else if (entry instanceof LibraryOrderEntry) { if (!openLibraryEditor && !((LibraryOrderEntry) entry) .getLibraryLevel() .equals(LibraryTableImplUtil.MODULE_LEVEL)) { rootConfigurable.select((LibraryOrderEntry) entry, true); } else { doEdit(); } } else if (entry instanceof JdkOrderEntry) { Sdk jdk = ((JdkOrderEntry) entry).getJdk(); if (jdk != null) { rootConfigurable.select(jdk, true); } } }
public boolean validate() throws ConfigurationException { final String moduleName = getModuleName(); if (myCreateModuleCb.isSelected() || !myWizardContext.isCreatingNewProject()) { final String moduleFileDirectory = myModuleFileLocation.getText(); if (moduleFileDirectory.length() == 0) { throw new ConfigurationException("Enter module file location"); } if (moduleName.length() == 0) { throw new ConfigurationException("Enter a module name"); } if (!ProjectWizardUtil.createDirectoryIfNotExists( IdeBundle.message("directory.module.file"), moduleFileDirectory, myImlLocationChangedByUser)) { return false; } if (!ProjectWizardUtil.createDirectoryIfNotExists( IdeBundle.message("directory.module.content.root"), myModuleContentRoot.getText(), myContentRootChangedByUser)) { return false; } File moduleFile = new File(moduleFileDirectory, moduleName + ModuleFileType.DOT_DEFAULT_EXTENSION); if (moduleFile.exists()) { int answer = Messages.showYesNoDialog( IdeBundle.message( "prompt.overwrite.project.file", moduleFile.getAbsolutePath(), IdeBundle.message("project.new.wizard.module.identification")), IdeBundle.message("title.file.already.exists"), Messages.getQuestionIcon()); if (answer != 0) { return false; } } } if (!myWizardContext.isCreatingNewProject()) { final Module module; final ProjectStructureConfigurable fromConfigurable = ProjectStructureConfigurable.getInstance(myWizardContext.getProject()); if (fromConfigurable != null) { module = fromConfigurable.getModulesConfig().getModule(moduleName); } else { module = ModuleManager.getInstance(myWizardContext.getProject()).findModuleByName(moduleName); } if (module != null) { throw new ConfigurationException( "Module \'" + moduleName + "\' already exist in project. Please, specify another name."); } } return !myWizardContext.isCreatingNewProject() || super.validate(); }
private void validateExistingModuleName() throws ConfigurationException { final String moduleName = getModuleName(); final Module module; final ProjectStructureConfigurable fromConfigurable = ProjectStructureConfigurable.getInstance(myWizardContext.getProject()); if (fromConfigurable != null) { module = fromConfigurable.getModulesConfig().getModule(moduleName); } else { module = ModuleManager.getInstance(myWizardContext.getProject()).findModuleByName(moduleName); } if (module != null) { throw new ConfigurationException( "Module \'" + moduleName + "\' already exist in project. Please, specify another name."); } }
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; }
private void refreshSolutionDescriptorName() { ModifiableModuleModel moduleModel = ProjectStructureConfigurable.getInstance(myContext.getProject()) .getContext() .getModulesConfigurator() .getModuleModel(); String moduleName = moduleModel.getNewName(myContext.getModule()); if (moduleName == null) { moduleName = myContext.getModule().getName(); } mySolutionNamespace.setText(moduleName); }
@Override public void navigate(boolean openLibraryEditor) { final OrderEntry entry = getSelectedEntry(); final ProjectStructureConfigurable rootConfigurable = ProjectStructureConfigurable.getInstance(myState.getProject()); if (entry instanceof ModuleOrderEntry) { Module module = ((ModuleOrderEntry) entry).getModule(); if (module != null) { rootConfigurable.select(module.getName(), null, true); } } else if (entry instanceof LibraryOrderEntry) { if (!openLibraryEditor) { rootConfigurable.select((LibraryOrderEntry) entry, true); } else { myEditButton.actionPerformed(null); } } else if (entry instanceof SdkOrderEntry) { Sdk jdk = ((SdkOrderEntry) entry).getSdk(); if (jdk != null) { rootConfigurable.select(jdk, true); } } }
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); } }); }
@NotNull @Override public ActionCallback navigate() { final Artifact artifact = myContext.getArtifactModel().getArtifactByOriginal(myArtifact); return ProjectStructureConfigurable.getInstance(myContext.getProject()) .select(myArtifact, true) .doWhenDone( new Runnable() { public void run() { final ArtifactEditorEx artifactEditor = (ArtifactEditorEx) myContext.getOrCreateEditor(artifact); if (myParentPath != null && myPackagingElement != null) { artifactEditor .getLayoutTreeComponent() .selectNode(myParentPath, myPackagingElement); } } }); }
private StructureConfigurableContext getStructureConfigurableContext() { return ProjectStructureConfigurable.getInstance(myState.getProject()).getContext(); }
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; }