public void configFacets(final List<MavenProjectsProcessorTask> postTasks) {
final ModuleType moduleType = ModuleType.get(myModule);
for (final MavenImporter importer : getSuitableImporters()) {
final MavenProjectChanges changes;
if (myMavenProjectChanges == null) {
if (importer.processChangedModulesOnly()) continue;
changes = MavenProjectChanges.NONE;
} else {
changes = myMavenProjectChanges;
}
if (importer.getModuleType() == moduleType) {
// facets use FacetConfiguration and like that do not have modifiable models,
// therefore we have to take write lock
MavenUtil.invokeAndWaitWriteAction(
myModule.getProject(),
new Runnable() {
public void run() {
importer.process(
myModifiableModelsProvider,
myModule,
myRootModelAdapter,
myMavenTree,
myMavenProject,
changes,
myMavenProjectToModuleName,
postTasks);
}
});
}
}
}
public Component getTableCellRendererComponent(
JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
final Color color = UIUtil.getTableFocusCellBackground();
Component component;
final Module module = value instanceof Module ? (Module) value : null;
try {
UIManager.put(UIUtil.TABLE_FOCUS_CELL_BACKGROUND_PROPERTY, table.getSelectionBackground());
component =
super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
if (module != null) {
setText(
module.getName()
+ " ("
+ FileUtil.toSystemDependentName(module.getModuleFilePath())
+ ")");
}
if (component instanceof JLabel) {
((JLabel) component).setBorder(noFocusBorder);
}
} finally {
UIManager.put(UIUtil.TABLE_FOCUS_CELL_BACKGROUND_PROPERTY, color);
}
component.setEnabled(ProcessedModulesTable.this.isEnabled());
if (component instanceof JLabel) {
final Icon icon = module != null ? ModuleType.get(module).getIcon() : null;
JLabel label = (JLabel) component;
label.setIcon(icon);
label.setDisabledIcon(icon);
}
component.setForeground(isSelected ? table.getSelectionForeground() : table.getForeground());
return component;
}
@Nullable
public static FlexUnitSupport getSupport(@Nullable Module module) {
if (module == null) return null;
if (ModuleType.get(module) != FlexModuleType.getInstance()
|| FlexUtils.getSdkForActiveBC(module) == null) return null;
return getSupport(GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module));
}
@Override
public void collectAllStepDefsProviders(
@NotNull List<VirtualFile> providers, @NotNull Project project) {
final Module[] modules = ModuleManager.getInstance(project).getModules();
for (Module module : modules) {
if (ModuleType.get(module) instanceof JavaModuleType) {
final VirtualFile[] roots = ModuleRootManager.getInstance(module).getContentRoots();
ContainerUtil.addAll(providers, roots);
}
}
}
public ModuleConfigurationEditor[] createEditors(@NotNull ModuleConfigurationState state) {
ModifiableRootModel rootModel = state.getRootModel();
Module module = rootModel.getModule();
if (!(ModuleType.get(module) instanceof GoModuleType)) {
return ModuleConfigurationEditor.EMPTY;
}
String moduleName = module.getName();
List<ModuleConfigurationEditor> editors = new ArrayList<ModuleConfigurationEditor>();
editors.add(new ContentEntriesEditor(moduleName, state));
editors.add(new OutputEditorEx(state));
editors.add(new ClasspathEditor(state));
return editors.toArray(new ModuleConfigurationEditor[editors.size()]);
}
@Override
protected void resetEditorFrom(@NotNull ErlangConsoleRunConfiguration config) {
myModuleComboBox.removeAllItems();
for (final Module module : config.getValidModules()) {
if (ModuleType.get(module) == ErlangModuleType.getInstance()) {
myModuleComboBox.addItem(module);
}
}
myModuleComboBox.setSelectedItem(myInitialModule);
//noinspection unchecked
myModuleComboBox.setRenderer(getListCellRendererWrapper());
myWorkingDirPathField.setText(config.getWorkingDirPath());
myModuleComboBox.setSelectedItem(config.getConfigurationModule().getModule());
myConsoleArgsEditor.setText(config.getConsoleArgs());
}
public ModuleConfigurationEditor[] createEditors(ModuleConfigurationState state) {
final Module module = state.getRootModel().getModule();
final ModuleType moduleType = ModuleType.get(module);
if (!(moduleType instanceof GoModuleType) && !(moduleType instanceof GoAppEngineModuleType)) {
return ModuleConfigurationEditor.EMPTY;
}
final DefaultModuleConfigurationEditorFactory editorFactory =
DefaultModuleConfigurationEditorFactory.getInstance();
List<ModuleConfigurationEditor> editors = new ArrayList<ModuleConfigurationEditor>();
editors.add(editorFactory.createModuleContentRootsEditor(state));
editors.add(editorFactory.createOutputEditor(state));
editors.add(editorFactory.createClasspathEditor(state));
// editors.add(new PluginModuleBuildConfEditor(state));
return editors.toArray(new ModuleConfigurationEditor[editors.size()]);
}
@NotNull
@Override
public List<SearchScope> getPredefinedScopes(
@NotNull final Project project,
@Nullable final DataContext dataContext,
boolean suggestSearchInLibs,
boolean prevSearchFiles,
boolean currentSelection,
boolean usageView,
boolean showEmptyScopes) {
Collection<SearchScope> result = ContainerUtil.newLinkedHashSet();
result.add(GlobalSearchScope.projectScope(project));
if (suggestSearchInLibs) {
result.add(GlobalSearchScope.allScope(project));
}
if (ModuleUtil.isSupportedRootType(project, JavaSourceRootType.TEST_SOURCE)) {
result.add(GlobalSearchScopesCore.projectProductionScope(project));
result.add(GlobalSearchScopesCore.projectTestScope(project));
}
final GlobalSearchScope openFilesScope = GlobalSearchScopes.openFilesScope(project);
if (openFilesScope != GlobalSearchScope.EMPTY_SCOPE) {
result.add(openFilesScope);
} else if (showEmptyScopes) {
result.add(
new LocalSearchScope(PsiElement.EMPTY_ARRAY, IdeBundle.message("scope.open.files")));
}
final Editor selectedTextEditor =
ApplicationManager.getApplication().isDispatchThread()
? FileEditorManager.getInstance(project).getSelectedTextEditor()
: null;
final PsiFile psiFile =
(selectedTextEditor != null)
? PsiDocumentManager.getInstance(project).getPsiFile(selectedTextEditor.getDocument())
: null;
PsiFile currentFile = psiFile;
if (dataContext != null) {
PsiElement dataContextElement = CommonDataKeys.PSI_FILE.getData(dataContext);
if (dataContextElement == null) {
dataContextElement = CommonDataKeys.PSI_ELEMENT.getData(dataContext);
}
if (dataContextElement == null && psiFile != null) {
dataContextElement = psiFile;
}
if (dataContextElement != null) {
if (!PlatformUtils.isCidr()) { // TODO: have an API to disable module scopes.
Module module = ModuleUtilCore.findModuleForPsiElement(dataContextElement);
if (module == null) {
module = LangDataKeys.MODULE.getData(dataContext);
}
if (module != null && !(ModuleType.get(module) instanceof InternalModuleType)) {
result.add(module.getModuleScope());
}
}
if (currentFile == null) {
currentFile = dataContextElement.getContainingFile();
}
}
}
if (currentFile != null || showEmptyScopes) {
PsiElement[] scope =
currentFile != null ? new PsiElement[] {currentFile} : PsiElement.EMPTY_ARRAY;
result.add(new LocalSearchScope(scope, IdeBundle.message("scope.current.file")));
}
if (currentSelection && selectedTextEditor != null && psiFile != null) {
SelectionModel selectionModel = selectedTextEditor.getSelectionModel();
if (selectionModel.hasSelection()) {
int start = selectionModel.getSelectionStart();
final PsiElement startElement = psiFile.findElementAt(start);
if (startElement != null) {
int end = selectionModel.getSelectionEnd();
final PsiElement endElement = psiFile.findElementAt(end);
if (endElement != null) {
final PsiElement parent = PsiTreeUtil.findCommonParent(startElement, endElement);
if (parent != null) {
final List<PsiElement> elements = new ArrayList<PsiElement>();
final PsiElement[] children = parent.getChildren();
TextRange selection = new TextRange(start, end);
for (PsiElement child : children) {
if (!(child instanceof PsiWhiteSpace)
&& child.getContainingFile() != null
&& selection.contains(child.getTextOffset())) {
elements.add(child);
}
}
if (!elements.isEmpty()) {
SearchScope local =
new LocalSearchScope(
PsiUtilCore.toPsiElementArray(elements),
IdeBundle.message("scope.selection"));
result.add(local);
}
}
}
}
}
}
if (usageView) {
addHierarchyScope(project, result);
UsageView selectedUsageView = UsageViewManager.getInstance(project).getSelectedUsageView();
if (selectedUsageView != null && !selectedUsageView.isSearchInProgress()) {
final Set<Usage> usages = ContainerUtil.newTroveSet(selectedUsageView.getUsages());
usages.removeAll(selectedUsageView.getExcludedUsages());
final List<PsiElement> results = new ArrayList<PsiElement>(usages.size());
if (prevSearchFiles) {
final Set<VirtualFile> files = collectFiles(usages, true);
if (!files.isEmpty()) {
GlobalSearchScope prev =
new GlobalSearchScope(project) {
private Set<VirtualFile> myFiles = null;
@NotNull
@Override
public String getDisplayName() {
return IdeBundle.message("scope.files.in.previous.search.result");
}
@Override
public synchronized boolean contains(@NotNull VirtualFile file) {
if (myFiles == null) {
myFiles = collectFiles(usages, false);
}
return myFiles.contains(file);
}
@Override
public int compare(@NotNull VirtualFile file1, @NotNull VirtualFile file2) {
return 0;
}
@Override
public boolean isSearchInModuleContent(@NotNull Module aModule) {
return true;
}
@Override
public boolean isSearchInLibraries() {
return true;
}
};
result.add(prev);
}
} else {
for (Usage usage : usages) {
if (usage instanceof PsiElementUsage) {
final PsiElement element = ((PsiElementUsage) usage).getElement();
if (element != null && element.isValid() && element.getContainingFile() != null) {
results.add(element);
}
}
}
if (!results.isEmpty()) {
result.add(
new LocalSearchScope(
PsiUtilCore.toPsiElementArray(results),
IdeBundle.message("scope.previous.search.results")));
}
}
}
}
final FavoritesManager favoritesManager = FavoritesManager.getInstance(project);
if (favoritesManager != null) {
for (final String favorite : favoritesManager.getAvailableFavoritesListNames()) {
final Collection<TreeItem<Pair<AbstractUrl, String>>> rootUrls =
favoritesManager.getFavoritesListRootUrls(favorite);
if (rootUrls.isEmpty()) continue; // ignore unused root
result.add(
new GlobalSearchScope(project) {
@NotNull
@Override
public String getDisplayName() {
return "Favorite \'" + favorite + "\'";
}
@Override
public boolean contains(@NotNull final VirtualFile file) {
return ApplicationManager.getApplication()
.runReadAction(
(Computable<Boolean>) () -> favoritesManager.contains(favorite, file));
}
@Override
public int compare(
@NotNull final VirtualFile file1, @NotNull final VirtualFile file2) {
return 0;
}
@Override
public boolean isSearchInModuleContent(@NotNull final Module aModule) {
return true;
}
@Override
public boolean isSearchInLibraries() {
return true;
}
});
}
}
ContainerUtil.addIfNotNull(result, getSelectedFilesScope(project, dataContext));
return ContainerUtil.newArrayList(result);
}
public boolean validateConfiguration(CompileScope compileScope) {
VirtualFile[] files = compileScope.getFiles(GroovyFileType.GROOVY_FILE_TYPE, true);
if (files.length == 0) return true;
final Set<String> scriptExtensions = GroovyFileTypeLoader.getCustomGroovyScriptExtensions();
final CompilerManager compilerManager = CompilerManager.getInstance(myProject);
Set<Module> modules = new HashSet<Module>();
for (VirtualFile file : files) {
if (scriptExtensions.contains(file.getExtension())
|| compilerManager.isExcludedFromCompilation(file)
|| CompilerConfiguration.getInstance(myProject).isResourceFile(file)) {
continue;
}
ProjectRootManager rootManager = ProjectRootManager.getInstance(myProject);
Module module = rootManager.getFileIndex().getModuleForFile(file);
if (module != null) {
modules.add(module);
}
}
Set<Module> nojdkModules = new HashSet<Module>();
for (Module module : modules) {
if (!GroovyUtils.isAcceptableModuleType(ModuleType.get(module))) continue;
final Sdk sdk = ModuleRootManager.getInstance(module).getSdk();
if (sdk == null || !(sdk.getSdkType() instanceof JavaSdkType)) {
nojdkModules.add(module);
continue;
}
if (!LibrariesUtil.hasGroovySdk(module)) {
if (!GroovyConfigUtils.getInstance().tryToSetUpGroovyFacetOntheFly(module)) {
Messages.showErrorDialog(
myProject,
GroovyBundle.message("cannot.compile.groovy.files.no.facet", module.getName()),
GroovyBundle.message("cannot.compile"));
ModulesConfigurator.showDialog(
module.getProject(), module.getName(), ClasspathEditor.NAME);
return false;
}
}
}
if (!nojdkModules.isEmpty()) {
final Module[] noJdkArray = nojdkModules.toArray(new Module[nojdkModules.size()]);
if (noJdkArray.length == 1) {
Messages.showErrorDialog(
myProject,
GroovyBundle.message("cannot.compile.groovy.files.no.sdk", noJdkArray[0].getName()),
GroovyBundle.message("cannot.compile"));
} else {
StringBuilder modulesList = new StringBuilder();
for (int i = 0; i < noJdkArray.length; i++) {
if (i > 0) modulesList.append(", ");
modulesList.append(noJdkArray[i].getName());
}
Messages.showErrorDialog(
myProject,
GroovyBundle.message("cannot.compile.groovy.files.no.sdk.mult", modulesList.toString()),
GroovyBundle.message("cannot.compile"));
}
return false;
}
final GroovyCompilerConfiguration configuration =
GroovyCompilerConfiguration.getInstance(myProject);
if (!configuration.transformsOk && needTransformCopying(compileScope)) {
final int result =
Messages.showYesNoDialog(
myProject,
"You seem to have global Groovy AST transformations defined in your project,\n"
+ "but they won't be applied to your code because they are not marked as compiler resources.\n"
+ "Do you want to add them to compiler resource list?\n"
+ "(you can do it yourself later in Settings | Compiler | Resource patterns)",
"AST Transformations found",
GroovyIcons.GROOVY_ICON_32x32);
if (result == 0) {
CompilerConfiguration.getInstance(myProject)
.addResourceFilePattern(AST_TRANSFORM_FILE_NAME);
} else {
configuration.transformsOk = true;
}
}
return true;
}
@Override
@Nullable
public ModuleType getSelectedModuleType() {
final Module module = getSelectedModule();
return module != null ? ModuleType.get(module) : null;
}
@Override
public boolean isSuitableModule(@NotNull Module module, @NotNull FacetsProvider facetsProvider) {
return ModuleType.get(module).equals(HaxeModuleType.getInstance());
}
