@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;
}
