private void editSdk(final Sdk currentSdk) {
final SdkModificator modificator = myModificators.get(currentSdk);
final EditSdkDialog dialog =
new EditSdkDialog(
myProject,
modificator,
s -> {
if (isDuplicateSdkName(s, currentSdk)) {
return PyBundle.message("sdk.details.dialog.error.duplicate.name");
}
return null;
});
if (dialog.showAndGet()) {
mySdkList.repaint();
final boolean pathChanged = !Comparing.equal(currentSdk.getHomePath(), dialog.getHomePath());
if (!modificator.getName().equals(dialog.getName())
|| pathChanged
|| dialog.isAssociateChanged()) {
myModifiedModificators.add(modificator);
modificator.setName(dialog.getName());
modificator.setHomePath(dialog.getHomePath());
if (dialog.isAssociateChanged()) {
setSdkAssociated(modificator, dialog.associateWithProject());
}
if (pathChanged) {
reloadSdk(currentSdk);
}
}
}
}
private void reloadSdk() {
final Sdk currentSdk = getSelectedSdk();
if (currentSdk != null) {
myModifiedModificators.add(myModificators.get(currentSdk));
reloadSdk(currentSdk);
}
}
private void addCreatedSdk(@Nullable final Sdk sdk, boolean newVirtualEnv) {
if (sdk != null) {
final PySdkService sdkService = PySdkService.getInstance();
sdkService.restoreSdk(sdk);
boolean isVirtualEnv = PythonSdkType.isVirtualEnv(sdk);
if (isVirtualEnv && !newVirtualEnv) {
AddVEnvOptionsDialog dialog = new AddVEnvOptionsDialog(myMainPanel);
dialog.show();
if (dialog.getExitCode() != DialogWrapper.OK_EXIT_CODE) {
return;
}
SdkModificator modificator = myModificators.get(sdk);
setSdkAssociated(modificator, !dialog.makeAvailableToAll());
myModifiedModificators.add(modificator);
}
final Sdk oldSdk = myProjectSdksModel.findSdk(sdk);
if (oldSdk == null) {
myProjectSdksModel.addSdk(sdk);
}
refreshSdkList();
mySdkList.setSelectedValue(myProjectSdksModel.findSdk(sdk.getName()), true);
mySdkListChanged = true;
}
}
private Set<Key> getActiveProviderKeys() {
Set<Key> result = new HashSet<Key>();
for (BeforeRunTask task : myModel.getItems()) {
result.add(task.getProviderId());
}
return result;
}
private void updateRightTreeModel() {
Set<PsiFile> deps = new HashSet<PsiFile>();
Set<PsiFile> scope = getSelectedScope(myLeftTree);
myIllegalsInRightTree = new HashSet<PsiFile>();
for (PsiFile psiFile : scope) {
Map<DependencyRule, Set<PsiFile>> illegalDeps = myIllegalDependencies.get(psiFile);
if (illegalDeps != null) {
for (final DependencyRule rule : illegalDeps.keySet()) {
myIllegalsInRightTree.addAll(illegalDeps.get(rule));
}
}
final Set<PsiFile> psiFiles = myDependencies.get(psiFile);
if (psiFiles != null) {
for (PsiFile file : psiFiles) {
if (file != null && file.isValid()) {
deps.add(file);
}
}
}
}
deps.removeAll(scope);
myRightTreeExpansionMonitor.freeze();
myRightTree.setModel(buildTreeModel(deps, myRightTreeMarker));
myRightTreeExpansionMonitor.restore();
expandFirstLevel(myRightTree);
}
private void checkForEmptyAndDuplicatedNames(
MyNode rootNode,
String prefix,
String title,
Class<? extends NamedConfigurable> configurableClass,
boolean recursively)
throws ConfigurationException {
final Set<String> names = new HashSet<String>();
for (int i = 0; i < rootNode.getChildCount(); i++) {
final MyNode node = (MyNode) rootNode.getChildAt(i);
final NamedConfigurable scopeConfigurable = node.getConfigurable();
if (configurableClass.isInstance(scopeConfigurable)) {
final String name = scopeConfigurable.getDisplayName();
if (name.trim().length() == 0) {
selectNodeInTree(node);
throw new ConfigurationException("Name should contain non-space characters");
}
if (names.contains(name)) {
final NamedConfigurable selectedConfigurable = getSelectedConfigurable();
if (selectedConfigurable == null
|| !Comparing.strEqual(selectedConfigurable.getDisplayName(), name)) {
selectNodeInTree(node);
}
throw new ConfigurationException(
CommonBundle.message("smth.already.exist.error.message", prefix, name), title);
}
names.add(name);
}
if (recursively) {
checkForEmptyAndDuplicatedNames(node, prefix, title, configurableClass, true);
}
}
}
private void calculateRoots() {
final ModuleManager moduleManager = ModuleManager.getInstance(myProject);
// assertion for read access inside
final Module[] modules =
ApplicationManager.getApplication()
.runReadAction(
new Computable<Module[]>() {
public Module[] compute() {
return moduleManager.getModules();
}
});
final TreeSet<VirtualFile> checkSet =
new TreeSet<VirtualFile>(FilePathComparator.getInstance());
myRoots = new HashSet<VirtualFile>();
myRoots.addAll(myInitialRoots);
checkSet.addAll(myInitialRoots);
for (Module module : modules) {
final VirtualFile[] files = ModuleRootManager.getInstance(module).getContentRoots();
for (VirtualFile file : files) {
final VirtualFile floor = checkSet.floor(file);
if (floor != null) {
myModulesSet.put(file, module.getName());
myRoots.add(file);
}
}
}
}
private static Set<PsiElement> getAllParents(PsiElement element) {
Set<PsiElement> parents = new java.util.HashSet<PsiElement>();
while (element != null) {
parents.add(element);
if (element instanceof PsiFile) break;
element = element.getParent();
}
return parents;
}
private void editRemoteSdk(Sdk currentSdk) {
PythonRemoteInterpreterManager remoteInterpreterManager =
PythonRemoteInterpreterManager.getInstance();
if (remoteInterpreterManager != null) {
final SdkModificator modificator = myModificators.get(currentSdk);
Set<Sdk> existingSdks = Sets.newHashSet(myProjectSdksModel.getSdks());
existingSdks.remove(currentSdk);
if (remoteInterpreterManager.editSdk(myProject, modificator, existingSdks)) {
myModifiedModificators.add(modificator);
}
}
}
private void combineToResourceBundleIfNeed(Collection<PsiFile> files) {
Collection<PropertiesFile> createdFiles =
ContainerUtil.map(
files,
(NotNullFunction<PsiFile, PropertiesFile>)
dom -> {
final PropertiesFile file = PropertiesImplUtil.getPropertiesFile(dom);
LOG.assertTrue(file != null, dom.getName());
return file;
});
ResourceBundle mainBundle = myResourceBundle;
final Set<ResourceBundle> allBundles = new HashSet<>();
if (mainBundle != null) {
allBundles.add(mainBundle);
}
boolean needCombining = false;
for (PropertiesFile file : createdFiles) {
final ResourceBundle rb = file.getResourceBundle();
if (mainBundle == null) {
mainBundle = rb;
} else if (!mainBundle.equals(rb)) {
needCombining = true;
}
allBundles.add(rb);
}
if (needCombining) {
final List<PropertiesFile> toCombine = new ArrayList<>(createdFiles);
final String baseName = getBaseName();
if (myResourceBundle != null) {
toCombine.addAll(myResourceBundle.getPropertiesFiles());
}
ResourceBundleManager manager = ResourceBundleManager.getInstance(mainBundle.getProject());
for (ResourceBundle bundle : allBundles) {
manager.dissociateResourceBundle(bundle);
}
manager.combineToResourceBundle(toCombine, baseName);
}
}
@NotNull
private Set<Usage> getReadOnlyUsages() {
final Set<Usage> result = new THashSet<Usage>();
final Set<Map.Entry<Usage, UsageNode>> usages = myUsageNodes.entrySet();
for (Map.Entry<Usage, UsageNode> entry : usages) {
Usage usage = entry.getKey();
UsageNode node = entry.getValue();
if (node != null && node != NULL_NODE && !node.isExcluded() && usage.isReadOnly()) {
result.add(usage);
}
}
return result;
}
private static void collectUsages(
@NotNull DefaultMutableTreeNode node, @NotNull Set<Usage> usages) {
if (node instanceof UsageNode) {
UsageNode usageNode = (UsageNode) node;
final Usage usage = usageNode.getUsage();
usages.add(usage);
}
Enumeration enumeration = node.children();
while (enumeration.hasMoreElements()) {
DefaultMutableTreeNode child = (DefaultMutableTreeNode) enumeration.nextElement();
collectUsages(child, usages);
}
}
@Override
@NotNull
public Set<Usage> getExcludedUsages() {
Set<Usage> result = new THashSet<Usage>();
for (Map.Entry<Usage, UsageNode> entry : myUsageNodes.entrySet()) {
UsageNode node = entry.getValue();
Usage usage = entry.getKey();
if (node == NULL_NODE || node == null) {
continue;
}
if (node.isExcluded()) {
result.add(usage);
}
}
return result;
}
private InspectionProfile guessProfileToSelect(
final InspectionProjectProfileManager profileManager) {
final Set<InspectionProfile> profiles = new HashSet<InspectionProfile>();
final RefEntity[] selectedElements = myTree.getSelectedElements();
for (RefEntity selectedElement : selectedElements) {
if (selectedElement instanceof RefElement) {
final RefElement refElement = (RefElement) selectedElement;
final PsiElement element = refElement.getElement();
if (element != null) {
profiles.add(profileManager.getInspectionProfile());
}
}
}
if (profiles.isEmpty()) {
return (InspectionProfile) profileManager.getProjectProfileImpl();
}
return profiles.iterator().next();
}
@Nullable
private UsageTarget[] getSelectedUsageTargets() {
TreePath[] selectionPaths = myTree.getSelectionPaths();
if (selectionPaths == null) return null;
Set<UsageTarget> targets = new THashSet<UsageTarget>();
for (TreePath selectionPath : selectionPaths) {
Object lastPathComponent = selectionPath.getLastPathComponent();
if (lastPathComponent instanceof UsageTargetNode) {
UsageTargetNode usageTargetNode = (UsageTargetNode) lastPathComponent;
UsageTarget target = usageTargetNode.getTarget();
if (target != null && target.isValid()) {
targets.add(target);
}
}
}
return targets.isEmpty() ? null : targets.toArray(new UsageTarget[targets.size()]);
}
private void getAllRunBeforeRuns(BeforeRunTask task, Set<RunConfiguration> configurationSet) {
if (task instanceof RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask) {
RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask runTask =
(RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask) task;
RunConfiguration configuration = runTask.getSettings().getConfiguration();
List<BeforeRunTask> tasks =
RunManagerImpl.getInstanceImpl(configuration.getProject())
.getBeforeRunTasks(configuration);
for (BeforeRunTask beforeRunTask : tasks) {
if (beforeRunTask
instanceof RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask) {
if (configurationSet.add(
((RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask) beforeRunTask)
.getSettings()
.getConfiguration())) getAllRunBeforeRuns(beforeRunTask, configurationSet);
}
}
}
}
private void collectGroupingRules() {
for (BreakpointPanelProvider provider : myBreakpointsPanelProviders) {
provider.createBreakpointsGroupingRules(myRulesAvailable);
}
myRulesEnabled.clear();
XBreakpointsDialogState settings = (getBreakpointManager()).getBreakpointsDialogSettings();
for (XBreakpointGroupingRule rule : myRulesAvailable) {
if (rule.isAlwaysEnabled()
|| (settings != null && settings.getSelectedGroupingRules().contains(rule.getId()))) {
myRulesEnabled.add(rule);
}
}
for (XBreakpointGroupingRule rule : myRulesAvailable) {
if (!rule.isAlwaysEnabled()) {
myToggleRuleActions.add(new ToggleBreakpointGroupingRuleEnabledAction(rule));
}
}
}
@NotNull
private Set<VirtualFile> getReadOnlyUsagesFiles() {
Set<Usage> usages = getReadOnlyUsages();
Set<VirtualFile> result = new THashSet<VirtualFile>();
for (Usage usage : usages) {
if (usage instanceof UsageInFile) {
UsageInFile usageInFile = (UsageInFile) usage;
VirtualFile file = usageInFile.getFile();
if (file != null) result.add(file);
}
if (usage instanceof UsageInFiles) {
UsageInFiles usageInFiles = (UsageInFiles) usage;
ContainerUtil.addAll(result, usageInFiles.getFiles());
}
}
for (UsageTarget target : myTargets) {
VirtualFile[] files = target.getFiles();
if (files == null) continue;
ContainerUtil.addAll(result, files);
}
return result;
}
private void updateDirectories(boolean updateFileCombo) {
final Module module = getModule();
List<VirtualFile> valuesDirs = Collections.emptyList();
if (module != null) {
final AndroidFacet facet = AndroidFacet.getInstance(module);
if (facet != null) {
myResourceDir = AndroidRootUtil.getResourceDir(facet);
if (myResourceDir != null) {
valuesDirs =
AndroidResourceUtil.getResourceSubdirs(
ResourceFolderType.VALUES.getName(), new VirtualFile[] {myResourceDir});
}
}
}
Collections.sort(
valuesDirs,
new Comparator<VirtualFile>() {
@Override
public int compare(VirtualFile f1, VirtualFile f2) {
return f1.getName().compareTo(f2.getName());
}
});
final Map<String, JCheckBox> oldCheckBoxes = myCheckBoxes;
final int selectedIndex = myDirectoriesList.getSelectedIndex();
final String selectedDirName = selectedIndex >= 0 ? myDirNames[selectedIndex] : null;
final List<JCheckBox> checkBoxList = new ArrayList<JCheckBox>();
myCheckBoxes = new HashMap<String, JCheckBox>();
myDirNames = new String[valuesDirs.size()];
int newSelectedIndex = -1;
int i = 0;
for (VirtualFile dir : valuesDirs) {
final String dirName = dir.getName();
final JCheckBox oldCheckBox = oldCheckBoxes.get(dirName);
final boolean selected = oldCheckBox != null && oldCheckBox.isSelected();
final JCheckBox checkBox = new JCheckBox(dirName, selected);
checkBoxList.add(checkBox);
myCheckBoxes.put(dirName, checkBox);
myDirNames[i] = dirName;
if (dirName.equals(selectedDirName)) {
newSelectedIndex = i;
}
i++;
}
myDirectoriesList.setModel(new CollectionListModel<JCheckBox>(checkBoxList));
if (newSelectedIndex >= 0) {
myDirectoriesList.setSelectedIndex(newSelectedIndex);
}
if (checkBoxList.size() == 1) {
checkBoxList.get(0).setSelected(true);
}
if (updateFileCombo) {
final Object oldItem = myFileNameCombo.getEditor().getItem();
final Set<String> fileNameSet = new HashSet<String>();
for (VirtualFile valuesDir : valuesDirs) {
for (VirtualFile file : valuesDir.getChildren()) {
fileNameSet.add(file.getName());
}
}
final List<String> fileNames = new ArrayList<String>(fileNameSet);
Collections.sort(fileNames);
myFileNameCombo.setModel(new DefaultComboBoxModel(fileNames.toArray()));
myFileNameCombo.getEditor().setItem(oldItem);
}
}
protected void initializeConfigurable(final NamedConfigurable configurable) {
myInitializedConfigurables.add(configurable);
}
private void showElementUsages(
@NotNull final FindUsagesHandler handler,
final Editor editor,
@NotNull final RelativePoint popupPosition,
final int maxUsages,
@NotNull final FindUsagesOptions options) {
ApplicationManager.getApplication().assertIsDispatchThread();
final UsageViewSettings usageViewSettings = UsageViewSettings.getInstance();
final UsageViewSettings savedGlobalSettings = new UsageViewSettings();
savedGlobalSettings.loadState(usageViewSettings);
usageViewSettings.loadState(myUsageViewSettings);
final Project project = handler.getProject();
UsageViewManager manager = UsageViewManager.getInstance(project);
FindUsagesManager findUsagesManager =
((FindManagerImpl) FindManager.getInstance(project)).getFindUsagesManager();
final UsageViewPresentation presentation =
findUsagesManager.createPresentation(handler, options);
presentation.setDetachedMode(true);
final UsageViewImpl usageView =
(UsageViewImpl)
manager.createUsageView(UsageTarget.EMPTY_ARRAY, Usage.EMPTY_ARRAY, presentation, null);
Disposer.register(
usageView,
new Disposable() {
@Override
public void dispose() {
myUsageViewSettings.loadState(usageViewSettings);
usageViewSettings.loadState(savedGlobalSettings);
}
});
final List<Usage> usages = new ArrayList<Usage>();
final Set<UsageNode> visibleNodes = new LinkedHashSet<UsageNode>();
UsageInfoToUsageConverter.TargetElementsDescriptor descriptor =
new UsageInfoToUsageConverter.TargetElementsDescriptor(
handler.getPrimaryElements(), handler.getSecondaryElements());
final MyTable table = new MyTable();
final AsyncProcessIcon processIcon = new AsyncProcessIcon("xxx");
boolean hadMoreSeparator = visibleNodes.remove(MORE_USAGES_SEPARATOR_NODE);
if (hadMoreSeparator) {
usages.add(MORE_USAGES_SEPARATOR);
visibleNodes.add(MORE_USAGES_SEPARATOR_NODE);
}
addUsageNodes(usageView.getRoot(), usageView, new ArrayList<UsageNode>());
TableScrollingUtil.installActions(table);
final List<UsageNode> data = collectData(usages, visibleNodes, usageView, presentation);
setTableModel(table, usageView, data);
SpeedSearchBase<JTable> speedSearch = new MySpeedSearch(table);
speedSearch.setComparator(new SpeedSearchComparator(false));
final JBPopup popup =
createUsagePopup(
usages,
descriptor,
visibleNodes,
handler,
editor,
popupPosition,
maxUsages,
usageView,
options,
table,
presentation,
processIcon,
hadMoreSeparator);
Disposer.register(popup, usageView);
// show popup only if find usages takes more than 300ms, otherwise it would flicker needlessly
Alarm alarm = new Alarm(usageView);
alarm.addRequest(
new Runnable() {
@Override
public void run() {
showPopupIfNeedTo(popup, popupPosition);
}
},
300);
final PingEDT pingEDT =
new PingEDT(
"Rebuild popup in EDT",
new Condition<Object>() {
@Override
public boolean value(Object o) {
return popup.isDisposed();
}
},
100,
new Runnable() {
@Override
public void run() {
if (popup.isDisposed()) return;
final List<UsageNode> nodes = new ArrayList<UsageNode>();
List<Usage> copy;
synchronized (usages) {
// open up popup as soon as several usages 've been found
if (!popup.isVisible()
&& (usages.size() <= 1 || !showPopupIfNeedTo(popup, popupPosition))) {
return;
}
addUsageNodes(usageView.getRoot(), usageView, nodes);
copy = new ArrayList<Usage>(usages);
}
rebuildPopup(
usageView,
copy,
nodes,
table,
popup,
presentation,
popupPosition,
!processIcon.isDisposed());
}
});
final MessageBusConnection messageBusConnection = project.getMessageBus().connect(usageView);
messageBusConnection.subscribe(
UsageFilteringRuleProvider.RULES_CHANGED,
new Runnable() {
@Override
public void run() {
pingEDT.ping();
}
});
Processor<Usage> collect =
new Processor<Usage>() {
private final UsageTarget[] myUsageTarget = {
new PsiElement2UsageTargetAdapter(handler.getPsiElement())
};
@Override
public boolean process(@NotNull Usage usage) {
synchronized (usages) {
if (!filter.shouldShow(usage)) return true;
if (visibleNodes.size() >= maxUsages) return false;
if (UsageViewManager.isSelfUsage(usage, myUsageTarget)) {
return true;
}
Usage usageToAdd = transform(usage);
if (usageToAdd == null) return true;
UsageNode node = usageView.doAppendUsage(usageToAdd);
usages.add(usageToAdd);
if (node != null) {
visibleNodes.add(node);
boolean continueSearch = true;
if (visibleNodes.size() == maxUsages) {
visibleNodes.add(MORE_USAGES_SEPARATOR_NODE);
usages.add(MORE_USAGES_SEPARATOR);
continueSearch = false;
}
pingEDT.ping();
return continueSearch;
}
return true;
}
}
};
final ProgressIndicator indicator =
FindUsagesManager.startProcessUsages(
handler,
handler.getPrimaryElements(),
handler.getSecondaryElements(),
collect,
options,
new Runnable() {
@Override
public void run() {
ApplicationManager.getApplication()
.invokeLater(
new Runnable() {
@Override
public void run() {
Disposer.dispose(processIcon);
Container parent = processIcon.getParent();
parent.remove(processIcon);
parent.repaint();
pingEDT.ping(); // repaint title
synchronized (usages) {
if (visibleNodes.isEmpty()) {
if (usages.isEmpty()) {
String text =
UsageViewBundle.message(
"no.usages.found.in",
searchScopePresentableName(options, project));
showHint(
text, editor, popupPosition, handler, maxUsages, options);
popup.cancel();
} else {
// all usages filtered out
}
} else if (visibleNodes.size() == 1) {
if (usages.size() == 1) {
// the only usage
Usage usage = visibleNodes.iterator().next().getUsage();
usage.navigate(true);
// String message =
// UsageViewBundle.message("show.usages.only.usage",
// searchScopePresentableName(options, project));
// navigateAndHint(usage, message, handler, popupPosition,
// maxUsages, options);
popup.cancel();
} else {
assert usages.size() > 1 : usages;
// usage view can filter usages down to one
Usage visibleUsage = visibleNodes.iterator().next().getUsage();
if (areAllUsagesInOneLine(visibleUsage, usages)) {
String hint =
UsageViewBundle.message(
"all.usages.are.in.this.line",
usages.size(),
searchScopePresentableName(options, project));
navigateAndHint(
visibleUsage,
hint,
handler,
popupPosition,
maxUsages,
options);
popup.cancel();
}
}
} else {
String title = presentation.getTabText();
boolean shouldShowMoreSeparator =
visibleNodes.contains(MORE_USAGES_SEPARATOR_NODE);
String fullTitle =
getFullTitle(
usages,
title,
shouldShowMoreSeparator,
visibleNodes.size() - (shouldShowMoreSeparator ? 1 : 0),
false);
((AbstractPopup) popup).setCaption(fullTitle);
}
}
}
},
project.getDisposed());
}
});
Disposer.register(
popup,
new Disposable() {
@Override
public void dispose() {
indicator.cancel();
}
});
}
public CreateXmlResourceDialog(
@NotNull Module module,
@NotNull ResourceType resourceType,
@Nullable String predefinedName,
@Nullable String predefinedValue,
boolean chooseName,
@Nullable VirtualFile defaultFile) {
super(module.getProject());
myResourceType = resourceType;
if (predefinedName != null && predefinedName.length() > 0) {
if (!chooseName) {
myNameLabel.setVisible(false);
myNameField.setVisible(false);
}
myNameField.setText(predefinedName);
}
if (predefinedValue != null && predefinedValue.length() > 0) {
myValueLabel.setVisible(false);
myValueField.setVisible(false);
myValueField.setText(predefinedValue);
}
final Set<Module> modulesSet = new HashSet<Module>();
modulesSet.add(module);
for (AndroidFacet depFacet : AndroidUtils.getAllAndroidDependencies(module, true)) {
modulesSet.add(depFacet.getModule());
}
assert modulesSet.size() > 0;
if (modulesSet.size() == 1) {
myModule = module;
myModuleLabel.setVisible(false);
myModuleCombo.setVisible(false);
} else {
myModule = null;
final Module[] modules = modulesSet.toArray(new Module[modulesSet.size()]);
Arrays.sort(
modules,
new Comparator<Module>() {
@Override
public int compare(Module m1, Module m2) {
return m1.getName().compareTo(m2.getName());
}
});
myModuleCombo.setModel(new DefaultComboBoxModel(modules));
myModuleCombo.setSelectedItem(module);
myModuleCombo.setRenderer(new ModuleListCellRendererWrapper(myModuleCombo.getRenderer()));
}
if (defaultFile == null) {
final String defaultFileName = AndroidResourceUtil.getDefaultResourceFileName(resourceType);
if (defaultFileName != null) {
myFileNameCombo.getEditor().setItem(defaultFileName);
}
}
myDirectoriesList = new CheckBoxList();
myDirectoriesLabel.setLabelFor(myDirectoriesList);
final ToolbarDecorator decorator = ToolbarDecorator.createDecorator(myDirectoriesList);
decorator.setEditAction(null);
decorator.disableUpDownActions();
decorator.setAddAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
doAddNewDirectory();
}
});
decorator.setRemoveAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
doDeleteDirectory();
}
});
final AnActionButton selectAll =
new AnActionButton("Select All", null, PlatformIcons.SELECT_ALL_ICON) {
@Override
public void actionPerformed(AnActionEvent e) {
doSelectAllDirs();
}
};
decorator.addExtraAction(selectAll);
final AnActionButton unselectAll =
new AnActionButton("Unselect All", null, PlatformIcons.UNSELECT_ALL_ICON) {
@Override
public void actionPerformed(AnActionEvent e) {
doUnselectAllDirs();
}
};
decorator.addExtraAction(unselectAll);
myDirectoriesPanel.add(decorator.createPanel());
updateDirectories(true);
myModuleCombo.addActionListener(
new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
updateDirectories(true);
}
});
final JCheckBox valuesCheckBox = myCheckBoxes.get(SdkConstants.FD_RES_VALUES);
if (valuesCheckBox != null) {
valuesCheckBox.setSelected(true);
}
if (defaultFile != null) {
resetFromFile(defaultFile, module.getProject());
}
init();
}
