public String getReportText() {
final Element rootElement = new Element("root");
rootElement.setAttribute("isBackward", String.valueOf(!myForward));
final List<PsiFile> files = new ArrayList<PsiFile>(myDependencies.keySet());
Collections.sort(
files,
new Comparator<PsiFile>() {
@Override
public int compare(PsiFile f1, PsiFile f2) {
final VirtualFile virtualFile1 = f1.getVirtualFile();
final VirtualFile virtualFile2 = f2.getVirtualFile();
if (virtualFile1 != null && virtualFile2 != null) {
return virtualFile1.getPath().compareToIgnoreCase(virtualFile2.getPath());
}
return 0;
}
});
for (PsiFile file : files) {
final Element fileElement = new Element("file");
fileElement.setAttribute("path", file.getVirtualFile().getPath());
for (PsiFile dep : myDependencies.get(file)) {
Element depElement = new Element("dependency");
depElement.setAttribute("path", dep.getVirtualFile().getPath());
fileElement.addContent(depElement);
}
rootElement.addContent(fileElement);
}
PathMacroManager.getInstance(myProject).collapsePaths(rootElement);
return JDOMUtil.writeDocument(new Document(rootElement), SystemProperties.getLineSeparator());
}
@Override
@NotNull
public List<Usage> getSortedUsages() {
List<Usage> usages = new ArrayList<Usage>(getUsages());
Collections.sort(usages, USAGE_COMPARATOR);
return usages;
}
private void fillList(final HighlightSeverity severity) {
DefaultListModel model = new DefaultListModel();
model.removeAllElements();
final List<SeverityBasedTextAttributes> infoTypes =
new ArrayList<SeverityBasedTextAttributes>();
infoTypes.addAll(SeverityUtil.getRegisteredHighlightingInfoTypes(mySeverityRegistrar));
Collections.sort(
infoTypes,
new Comparator<SeverityBasedTextAttributes>() {
@Override
public int compare(
SeverityBasedTextAttributes attributes1, SeverityBasedTextAttributes attributes2) {
return -mySeverityRegistrar.compare(
attributes1.getSeverity(), attributes2.getSeverity());
}
});
SeverityBasedTextAttributes preselection = null;
for (SeverityBasedTextAttributes type : infoTypes) {
model.addElement(type);
if (type.getSeverity().equals(severity)) {
preselection = type;
}
}
myOptionsList.setModel(model);
myOptionsList.setSelectedValue(preselection, true);
}
private void processDependencies(
final Set<PsiFile> searchIn,
final Set<PsiFile> searchFor,
Processor<List<PsiFile>> processor) {
if (myTransitiveBorder == 0) return;
Set<PsiFile> initialSearchFor = new HashSet<PsiFile>(searchFor);
for (DependenciesBuilder builder : myBuilders) {
for (PsiFile from : searchIn) {
for (PsiFile to : initialSearchFor) {
final List<List<PsiFile>> paths = builder.findPaths(from, to);
Collections.sort(
paths,
new Comparator<List<PsiFile>>() {
public int compare(final List<PsiFile> p1, final List<PsiFile> p2) {
return p1.size() - p2.size();
}
});
for (List<PsiFile> path : paths) {
if (!path.isEmpty()) {
path.add(0, from);
path.add(to);
if (!processor.process(path)) return;
}
}
}
}
}
}
private static UsageGroupingRule[] getActiveGroupingRules(final Project project) {
final UsageGroupingRuleProvider[] providers =
Extensions.getExtensions(UsageGroupingRuleProvider.EP_NAME);
List<UsageGroupingRule> list = new ArrayList<UsageGroupingRule>(providers.length);
for (UsageGroupingRuleProvider provider : providers) {
ContainerUtil.addAll(list, provider.getActiveRules(project));
}
Collections.sort(
list,
new Comparator<UsageGroupingRule>() {
@Override
public int compare(final UsageGroupingRule o1, final UsageGroupingRule o2) {
return getRank(o1) - getRank(o2);
}
private int getRank(final UsageGroupingRule rule) {
if (rule instanceof OrderableUsageGroupingRule) {
return ((OrderableUsageGroupingRule) rule).getRank();
}
return Integer.MAX_VALUE;
}
});
return list.toArray(new UsageGroupingRule[list.size()]);
}
private MyTableModel() {
myAll = Registry.getAll();
Collections.sort(
myAll,
new Comparator<RegistryValue>() {
public int compare(RegistryValue o1, RegistryValue o2) {
return o1.getKey().compareTo(o2.getKey());
}
});
}
private static void sortNode(ParentNode node, final Comparator<ElementNode> sortComparator) {
ArrayList<MemberNode> arrayList = new ArrayList<MemberNode>();
Enumeration<MemberNode> children = node.children();
while (children.hasMoreElements()) {
arrayList.add(children.nextElement());
}
Collections.sort(arrayList, sortComparator);
replaceChildren(node, arrayList);
}
ObjectWithWeight(Object element, String pattern, SpeedSearchComparator comparator) {
this.node = element;
final String text = getElementText(element);
if (text != null) {
final Iterable<TextRange> ranges = comparator.matchingFragments(pattern, text);
if (ranges != null) {
for (TextRange range : ranges) {
weights.add(range);
}
}
}
Collections.sort(weights, TEXT_RANGE_COMPARATOR);
}
protected void restoreTree() {
Pair<ElementNode, List<ElementNode>> selection = storeSelection();
DefaultMutableTreeNode root = getRootNode();
if (!myShowClasses || myContainerNodes.isEmpty()) {
List<ParentNode> otherObjects = new ArrayList<ParentNode>();
Enumeration<ParentNode> children = getRootNodeChildren();
ParentNode newRoot =
new ParentNode(
null, new MemberChooserObjectBase(getAllContainersNodeName()), new Ref<Integer>(0));
while (children.hasMoreElements()) {
final ParentNode nextElement = children.nextElement();
if (nextElement instanceof ContainerNode) {
final ContainerNode containerNode = (ContainerNode) nextElement;
Enumeration<MemberNode> memberNodes = containerNode.children();
List<MemberNode> memberNodesList = new ArrayList<MemberNode>();
while (memberNodes.hasMoreElements()) {
memberNodesList.add(memberNodes.nextElement());
}
for (MemberNode memberNode : memberNodesList) {
newRoot.add(memberNode);
}
} else {
otherObjects.add(nextElement);
}
}
replaceChildren(root, otherObjects);
sortNode(newRoot, myComparator);
if (newRoot.children().hasMoreElements()) root.add(newRoot);
} else {
Enumeration<ParentNode> children = getRootNodeChildren();
while (children.hasMoreElements()) {
ParentNode allClassesNode = children.nextElement();
Enumeration<MemberNode> memberNodes = allClassesNode.children();
ArrayList<MemberNode> arrayList = new ArrayList<MemberNode>();
while (memberNodes.hasMoreElements()) {
arrayList.add(memberNodes.nextElement());
}
Collections.sort(arrayList, myComparator);
for (MemberNode memberNode : arrayList) {
myNodeToParentMap.get(memberNode).add(memberNode);
}
}
replaceChildren(root, myContainerNodes);
}
myTreeModel.nodeStructureChanged(root);
defaultExpandTree();
restoreSelection(selection);
}
private static void sortInjections(final List<BaseInjection> injections) {
Collections.sort(
injections,
new Comparator<BaseInjection>() {
public int compare(final BaseInjection o1, final BaseInjection o2) {
final int support = Comparing.compare(o1.getSupportId(), o2.getSupportId());
if (support != 0) return support;
final int lang =
Comparing.compare(o1.getInjectedLanguageId(), o2.getInjectedLanguageId());
if (lang != 0) return lang;
return Comparing.compare(o1.getDisplayName(), o2.getDisplayName());
}
});
}
@Nullable
private Object findClosestTo(PsiElement path, ArrayList<ObjectWithWeight> paths) {
if (path == null || myInitialPsiElement == null) {
return paths.get(0).node;
}
final Set<PsiElement> parents = getAllParents(myInitialPsiElement);
ArrayList<ObjectWithWeight> cur = new ArrayList<ObjectWithWeight>();
int max = -1;
for (ObjectWithWeight p : paths) {
final Object last = ((TreePath) p.node).getLastPathComponent();
final List<PsiElement> elements = new ArrayList<PsiElement>();
final Object object = ((DefaultMutableTreeNode) last).getUserObject();
if (object instanceof FilteringTreeStructure.FilteringNode) {
FilteringTreeStructure.FilteringNode node = (FilteringTreeStructure.FilteringNode) object;
FilteringTreeStructure.FilteringNode candidate = node;
while (node != null) {
elements.add(getPsi(node));
node = node.getParentNode();
}
final int size = ContainerUtil.intersection(parents, elements).size();
if (size == elements.size() - 1
&& size == parents.size() - (myInitialNodeIsLeaf ? 1 : 0)
&& candidate.children().isEmpty()) {
return p.node;
}
if (size > max) {
max = size;
cur.clear();
cur.add(p);
} else if (size == max) {
cur.add(p);
}
}
}
Collections.sort(
cur,
new Comparator<ObjectWithWeight>() {
@Override
public int compare(ObjectWithWeight o1, ObjectWithWeight o2) {
final int i = o1.compareWith(o2);
return i != 0
? i
: ((TreePath) o2.node).getPathCount() - ((TreePath) o1.node).getPathCount();
}
});
return cur.isEmpty() ? null : cur.get(0).node;
}
private void sortChildren(CheckedTreeNode node) {
final int childCount = node.getChildCount();
if (childCount == 0) {
return;
}
final List<CheckedTreeNode> children = new ArrayList<CheckedTreeNode>(childCount);
for (int idx = 0; idx < childCount; idx++) {
children.add((CheckedTreeNode) node.getChildAt(idx));
}
for (CheckedTreeNode child : children) {
sortChildren(child);
child.removeFromParent();
}
Collections.sort(children, myNodeComparator);
for (CheckedTreeNode child : children) {
node.add(child);
}
}
@NotNull
private static List<UsageNode> collectData(
@NotNull List<Usage> usages,
@NotNull Collection<UsageNode> visibleNodes,
@NotNull UsageViewImpl usageView,
@NotNull UsageViewPresentation presentation) {
@NotNull List<UsageNode> data = new ArrayList<UsageNode>();
int filtered = filtered(usages, usageView);
if (filtered != 0) {
data.add(createStringNode(UsageViewBundle.message("usages.were.filtered.out", filtered)));
}
data.addAll(visibleNodes);
if (data.isEmpty()) {
String progressText = UsageViewManagerImpl.getProgressTitle(presentation);
data.add(createStringNode(progressText));
}
Collections.sort(data, USAGE_NODE_COMPARATOR);
return data;
}
@Override
public Configurable[] getConfigurables() {
if (myConfigurables == null) {
final ArrayList<Configurable> configurables = new ArrayList<Configurable>();
for (LanguageInjectionSupport support : InjectorUtils.getActiveInjectionSupports()) {
ContainerUtil.addAll(configurables, support.createSettings(myProject, myConfiguration));
}
Collections.sort(
configurables,
new Comparator<Configurable>() {
public int compare(final Configurable o1, final Configurable o2) {
return Comparing.compare(o1.getDisplayName(), o2.getDisplayName());
}
});
myConfigurables = configurables.toArray(new Configurable[configurables.size()]);
}
return myConfigurables;
}
private MyExistLocalesListModel() {
myLocales = new ArrayList<>();
myLocales.add(PropertiesUtil.DEFAULT_LOCALE);
PropertiesReferenceManager.getInstance(myProject)
.processPropertiesFiles(
GlobalSearchScope.projectScope(myProject),
new PropertiesFileProcessor() {
@Override
public boolean process(String baseName, PropertiesFile propertiesFile) {
final Locale locale = propertiesFile.getLocale();
if (locale != PropertiesUtil.DEFAULT_LOCALE && !myLocales.contains(locale)) {
myLocales.add(locale);
}
return true;
}
},
BundleNameEvaluator.DEFAULT);
Collections.sort(myLocales, LOCALE_COMPARATOR);
}
private static TreeNode groupAndSortArchetypes(Set<MavenArchetype> archetypes) {
List<MavenArchetype> list = new ArrayList<MavenArchetype>(archetypes);
Collections.sort(
list,
new Comparator<MavenArchetype>() {
public int compare(MavenArchetype o1, MavenArchetype o2) {
String key1 = o1.groupId + ":" + o1.artifactId;
String key2 = o2.groupId + ":" + o2.artifactId;
int result = key1.compareToIgnoreCase(key2);
if (result != 0) return result;
return o2.version.compareToIgnoreCase(o1.version);
}
});
Map<String, List<MavenArchetype>> map = new TreeMap<String, List<MavenArchetype>>();
for (MavenArchetype each : list) {
String key = each.groupId + ":" + each.artifactId;
List<MavenArchetype> versions = map.get(key);
if (versions == null) {
versions = new ArrayList<MavenArchetype>();
map.put(key, versions);
}
versions.add(each);
}
DefaultMutableTreeNode result = new DefaultMutableTreeNode("root", true);
for (List<MavenArchetype> each : map.values()) {
MavenArchetype eachArchetype = each.get(0);
DefaultMutableTreeNode node = new DefaultMutableTreeNode(eachArchetype, true);
for (MavenArchetype eachVersion : each) {
DefaultMutableTreeNode versionNode = new DefaultMutableTreeNode(eachVersion, false);
node.add(versionNode);
}
result.add(node);
}
return result;
}
private void rulesChanged() {
ApplicationManager.getApplication().assertIsDispatchThread();
final ArrayList<UsageState> states = new ArrayList<UsageState>();
captureUsagesExpandState(new TreePath(myTree.getModel().getRoot()), states);
final List<Usage> allUsages = new ArrayList<Usage>(myUsageNodes.keySet());
Collections.sort(allUsages, USAGE_COMPARATOR);
final Set<Usage> excludedUsages = getExcludedUsages();
reset();
myBuilder.setGroupingRules(getActiveGroupingRules(myProject));
myBuilder.setFilteringRules(getActiveFilteringRules(myProject));
ApplicationManager.getApplication()
.runReadAction(
new Runnable() {
@Override
public void run() {
for (Usage usage : allUsages) {
if (!usage.isValid()) {
continue;
}
if (usage instanceof MergeableUsage) {
((MergeableUsage) usage).reset();
}
appendUsage(usage);
}
}
});
excludeUsages(excludedUsages.toArray(new Usage[excludedUsages.size()]));
if (myCentralPanel != null) {
setupCentralPanel();
}
SwingUtilities.invokeLater(
new Runnable() {
@Override
public void run() {
if (isDisposed) return;
restoreUsageExpandState(states);
updateImmediately();
}
});
}
private MyTableModel() {
myAll = Registry.getAll();
final List<String> recent = getRecent();
Collections.sort(
myAll,
new Comparator<RegistryValue>() {
@Override
public int compare(@NotNull RegistryValue o1, @NotNull RegistryValue o2) {
final String key1 = o1.getKey();
final String key2 = o2.getKey();
final int i1 = recent.indexOf(key1);
final int i2 = recent.indexOf(key2);
final boolean c1 = i1 != -1;
final boolean c2 = i2 != -1;
if (c1 && !c2) return -1;
if (!c1 && c2) return 1;
if (c1 && c2) return i1 - i2;
return key1.compareToIgnoreCase(key2);
}
});
}
public void sort(Comparator<T> comparator) {
Collections.sort(myElements, comparator);
fireTableDataChanged();
}
public void setChangeLists(Collection<? extends ChangeList> changeLists) {
List<ChangeList> list = new ArrayList<ChangeList>(changeLists);
Collections.sort(list, CHANGE_LIST_COMPARATOR);
myExistingListsCombo.setModel(new CollectionComboBoxModel(list, null));
}
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);
}
}
@Nullable
private DependencyOnPlugin editPluginDependency(
@NotNull JComponent parent, @NotNull final DependencyOnPlugin original) {
List<String> pluginIds = new ArrayList<String>(getPluginNameByIdMap().keySet());
if (!original.getPluginId().isEmpty() && !pluginIds.contains(original.getPluginId())) {
pluginIds.add(original.getPluginId());
}
Collections.sort(
pluginIds,
new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return getPluginNameById(o1).compareToIgnoreCase(getPluginNameById(o2));
}
});
final ComboBox pluginChooser = new ComboBox(ArrayUtilRt.toStringArray(pluginIds), 250);
pluginChooser.setRenderer(
new ListCellRendererWrapper<String>() {
@Override
public void customize(
JList list, String value, int index, boolean selected, boolean hasFocus) {
setText(getPluginNameById(value));
}
});
new ComboboxSpeedSearch(pluginChooser) {
@Override
protected String getElementText(Object element) {
return getPluginNameById((String) element);
}
};
pluginChooser.setSelectedItem(original.getPluginId());
final JBTextField minVersionField =
new JBTextField(StringUtil.notNullize(original.getMinVersion()));
final JBTextField maxVersionField =
new JBTextField(StringUtil.notNullize(original.getMaxVersion()));
final JBTextField channelField = new JBTextField(StringUtil.notNullize(original.getChannel()));
minVersionField.getEmptyText().setText("<any>");
minVersionField.setColumns(10);
maxVersionField.getEmptyText().setText("<any>");
maxVersionField.setColumns(10);
channelField.setColumns(10);
JPanel panel =
FormBuilder.createFormBuilder()
.addLabeledComponent("Plugin:", pluginChooser)
.addLabeledComponent("Minimum version:", minVersionField)
.addLabeledComponent("Maximum version:", maxVersionField)
.addLabeledComponent("Channel:", channelField)
.getPanel();
final DialogBuilder dialogBuilder =
new DialogBuilder(parent).title("Required Plugin").centerPanel(panel);
dialogBuilder.setPreferredFocusComponent(pluginChooser);
pluginChooser.addActionListener(
new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
dialogBuilder.setOkActionEnabled(
!StringUtil.isEmpty((String) pluginChooser.getSelectedItem()));
}
});
if (dialogBuilder.show() == DialogWrapper.OK_EXIT_CODE) {
return new DependencyOnPlugin(
((String) pluginChooser.getSelectedItem()),
StringUtil.nullize(minVersionField.getText().trim()),
StringUtil.nullize(maxVersionField.getText().trim()),
StringUtil.nullize(channelField.getText().trim()));
}
return null;
}
private void createActions(ToolbarDecorator decorator) {
final Consumer<BaseInjection> consumer =
new Consumer<BaseInjection>() {
public void consume(final BaseInjection injection) {
addInjection(injection);
}
};
final Factory<BaseInjection> producer =
new NullableFactory<BaseInjection>() {
public BaseInjection create() {
final InjInfo info = getSelectedInjection();
return info == null ? null : info.injection;
}
};
for (LanguageInjectionSupport support : InjectorUtils.getActiveInjectionSupports()) {
ContainerUtil.addAll(myAddActions, support.createAddActions(myProject, consumer));
final AnAction action = support.createEditAction(myProject, producer);
myEditActions.put(
support.getId(),
action == null
? AbstractLanguageInjectionSupport.createDefaultEditAction(myProject, producer)
: action);
mySupports.put(support.getId(), support);
}
Collections.sort(
myAddActions,
new Comparator<AnAction>() {
public int compare(final AnAction o1, final AnAction o2) {
return Comparing.compare(
o1.getTemplatePresentation().getText(), o2.getTemplatePresentation().getText());
}
});
decorator.disableUpDownActions();
decorator.setAddActionUpdater(
new AnActionButtonUpdater() {
@Override
public boolean isEnabled(AnActionEvent e) {
return !myAddActions.isEmpty();
}
});
decorator.setAddAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
performAdd(button);
}
});
decorator.setRemoveActionUpdater(
new AnActionButtonUpdater() {
@Override
public boolean isEnabled(AnActionEvent e) {
boolean enabled = false;
for (InjInfo info : getSelectedInjections()) {
if (!info.bundled) {
enabled = true;
break;
}
}
return enabled;
}
});
decorator.setRemoveAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
performRemove();
}
});
decorator.setEditActionUpdater(
new AnActionButtonUpdater() {
@Override
public boolean isEnabled(AnActionEvent e) {
AnAction edit = getEditAction();
if (edit != null) edit.update(e);
return edit != null && edit.getTemplatePresentation().isEnabled();
}
});
decorator.setEditAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
performEditAction();
}
});
decorator.addExtraAction(
new DumbAwareActionButton("Duplicate", "Duplicate", PlatformIcons.COPY_ICON) {
@Override
public boolean isEnabled() {
return getEditAction() != null;
}
@Override
public void actionPerformed(@NotNull AnActionEvent e) {
final InjInfo injection = getSelectedInjection();
if (injection != null) {
addInjection(injection.injection.copy());
// performEditAction(e);
}
}
});
decorator.addExtraAction(
new DumbAwareActionButton(
"Enable Selected Injections",
"Enable Selected Injections",
PlatformIcons.SELECT_ALL_ICON) {
@Override
public void actionPerformed(@NotNull final AnActionEvent e) {
performSelectedInjectionsEnabled(true);
}
});
decorator.addExtraAction(
new DumbAwareActionButton(
"Disable Selected Injections",
"Disable Selected Injections",
PlatformIcons.UNSELECT_ALL_ICON) {
@Override
public void actionPerformed(@NotNull final AnActionEvent e) {
performSelectedInjectionsEnabled(false);
}
});
new DumbAwareAction("Toggle") {
@Override
public void update(@NotNull AnActionEvent e) {
SpeedSearchSupply supply = SpeedSearchSupply.getSupply(myInjectionsTable);
e.getPresentation().setEnabled(supply == null || !supply.isPopupActive());
}
@Override
public void actionPerformed(@NotNull final AnActionEvent e) {
performToggleAction();
}
}.registerCustomShortcutSet(
new CustomShortcutSet(KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0)), myInjectionsTable);
if (myInfos.length > 1) {
AnActionButton shareAction =
new DumbAwareActionButton("Move to IDE Scope", null, PlatformIcons.IMPORT_ICON) {
{
addCustomUpdater(
new AnActionButtonUpdater() {
@Override
public boolean isEnabled(AnActionEvent e) {
CfgInfo cfg = getTargetCfgInfo(getSelectedInjections());
e.getPresentation()
.setText(
cfg == getDefaultCfgInfo()
? "Move to IDE Scope"
: "Move to Project Scope");
return cfg != null;
}
});
}
@Override
public void actionPerformed(@NotNull final AnActionEvent e) {
final List<InjInfo> injections = getSelectedInjections();
final CfgInfo cfg = getTargetCfgInfo(injections);
if (cfg == null) return;
for (InjInfo info : injections) {
if (info.cfgInfo == cfg) continue;
if (info.bundled) continue;
info.cfgInfo.injectionInfos.remove(info);
cfg.addInjection(info.injection);
}
final int[] selectedRows = myInjectionsTable.getSelectedRows();
myInjectionsTable.getListTableModel().setItems(getInjInfoList(myInfos));
TableUtil.selectRows(myInjectionsTable, selectedRows);
}
@Nullable
private CfgInfo getTargetCfgInfo(final List<InjInfo> injections) {
CfgInfo cfg = null;
for (InjInfo info : injections) {
if (info.bundled) {
continue;
}
if (cfg == null) cfg = info.cfgInfo;
else if (cfg != info.cfgInfo) return info.cfgInfo;
}
if (cfg == null) return null;
for (CfgInfo info : myInfos) {
if (info != cfg) return info;
}
throw new AssertionError();
}
};
shareAction.setShortcut(
new CustomShortcutSet(
KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, InputEvent.SHIFT_DOWN_MASK)));
decorator.addExtraAction(shareAction);
}
decorator.addExtraAction(
new DumbAwareActionButton("Import", "Import", AllIcons.Actions.Install) {
@Override
public void actionPerformed(@NotNull final AnActionEvent e) {
doImportAction(e.getDataContext());
updateCountLabel();
}
});
decorator.addExtraAction(
new DumbAwareActionButton("Export", "Export", AllIcons.Actions.Export) {
@Override
public void actionPerformed(@NotNull final AnActionEvent e) {
final List<BaseInjection> injections = getInjectionList(getSelectedInjections());
final VirtualFileWrapper wrapper =
FileChooserFactory.getInstance()
.createSaveFileDialog(
new FileSaverDescriptor("Export Selected Injections to File...", "", "xml"),
myProject)
.save(null, null);
if (wrapper == null) return;
final Configuration configuration = new Configuration();
configuration.setInjections(injections);
final Document document = new Document(configuration.getState());
try {
JDOMUtil.writeDocument(document, wrapper.getFile(), "\n");
} catch (IOException ex) {
final String msg = ex.getLocalizedMessage();
Messages.showErrorDialog(
myProject,
msg != null && msg.length() > 0 ? msg : ex.toString(),
"Export Failed");
}
}
@Override
public boolean isEnabled() {
return !getSelectedInjections().isEmpty();
}
});
}