private void setupCentralPanel() {
myCentralPanel.removeAll();
if (myUsagePreviewPanel != null) {
Disposer.dispose(myUsagePreviewPanel);
myUsagePreviewPanel = null;
}
JScrollPane pane = ScrollPaneFactory.createScrollPane(myTree);
if (UsageViewSettings.getInstance().IS_PREVIEW_USAGES) {
Splitter splitter =
new Splitter(false, UsageViewSettings.getInstance().PREVIEW_USAGES_SPLITTER_PROPORTIONS);
pane.putClientProperty(UIUtil.KEEP_BORDER_SIDES, SideBorder.RIGHT);
splitter.setFirstComponent(pane);
myUsagePreviewPanel = new UsagePreviewPanel(myProject);
myUsagePreviewPanel.setBorder(IdeBorderFactory.createBorder(SideBorder.LEFT));
Disposer.register(this, myUsagePreviewPanel);
splitter.setSecondComponent(myUsagePreviewPanel);
myCentralPanel.add(splitter, BorderLayout.CENTER);
} else {
myCentralPanel.add(pane, BorderLayout.CENTER);
}
myCentralPanel.add(myButtonPanel, BorderLayout.SOUTH);
myRootPanel.revalidate();
}
protected JComponent createCenterPanel() {
JScrollPane scrollPane = ScrollPaneFactory.createScrollPane(myTree);
scrollPane.setBorder(IdeBorderFactory.createBorder(SideBorder.LEFT));
myCenterPanel.add(CARD_STATUS, scrollPane);
myTreeBrowser =
new CommittedChangesTreeBrowser(myProject, Collections.<CommittedChangeList>emptyList());
Disposer.register(this, myTreeBrowser);
myTreeBrowser.setHelpId(getHelpId());
myCenterPanel.add(CARD_CHANGES, myTreeBrowser);
return myCenterPanel;
}
public void addButtonRunnable(int index, final Runnable runnable, String text) {
if (getBorder() == null) setBorder(IdeBorderFactory.createBorder(SideBorder.TOP));
final JButton button = new JButton(UIUtil.replaceMnemonicAmpersand(text));
DialogUtil.registerMnemonic(button);
button.setFocusable(false);
button.addActionListener(
new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
runnable.run();
}
});
add(button, index);
invalidate();
if (getParent() != null) {
getParent().validate();
}
}
public JComponent createCenterPanel() {
List<FileStructureFilter> fileStructureFilters = new ArrayList<FileStructureFilter>();
List<FileStructureNodeProvider> fileStructureNodeProviders =
new ArrayList<FileStructureNodeProvider>();
if (myTreeActionsOwner != null) {
for (Filter filter : myBaseTreeModel.getFilters()) {
if (filter instanceof FileStructureFilter) {
final FileStructureFilter fsFilter = (FileStructureFilter) filter;
myTreeActionsOwner.setActionIncluded(fsFilter, true);
fileStructureFilters.add(fsFilter);
}
}
if (myBaseTreeModel instanceof ProvidingTreeModel) {
for (NodeProvider provider : ((ProvidingTreeModel) myBaseTreeModel).getNodeProviders()) {
if (provider instanceof FileStructureNodeProvider) {
fileStructureNodeProviders.add((FileStructureNodeProvider) provider);
}
}
}
}
final JPanel panel = new JPanel(new BorderLayout());
JPanel comboPanel = new JPanel(new GridLayout(0, 2, 0, 0));
final Shortcut[] F4 =
ActionManager.getInstance()
.getAction(IdeActions.ACTION_EDIT_SOURCE)
.getShortcutSet()
.getShortcuts();
final Shortcut[] ENTER = CustomShortcutSet.fromString("ENTER").getShortcuts();
final CustomShortcutSet shortcutSet = new CustomShortcutSet(ArrayUtil.mergeArrays(F4, ENTER));
new AnAction() {
public void actionPerformed(AnActionEvent e) {
final boolean succeeded = navigateSelectedElement();
if (succeeded) {
unregisterCustomShortcutSet(panel);
}
}
}.registerCustomShortcutSet(shortcutSet, panel);
new AnAction() {
public void actionPerformed(AnActionEvent e) {
if (mySpeedSearch != null && mySpeedSearch.isPopupActive()) {
mySpeedSearch.hidePopup();
} else {
myPopup.cancel();
}
}
}.registerCustomShortcutSet(CustomShortcutSet.fromString("ESCAPE"), myTree);
new ClickListener() {
@Override
public boolean onClick(MouseEvent e, int clickCount) {
navigateSelectedElement();
return true;
}
}.installOn(myTree);
for (FileStructureFilter filter : fileStructureFilters) {
addCheckbox(comboPanel, filter);
}
for (FileStructureNodeProvider provider : fileStructureNodeProviders) {
addCheckbox(comboPanel, provider);
}
myPreferredWidth = Math.max(comboPanel.getPreferredSize().width, 350);
panel.add(comboPanel, BorderLayout.NORTH);
JScrollPane scrollPane = ScrollPaneFactory.createScrollPane(myAbstractTreeBuilder.getTree());
scrollPane.setBorder(IdeBorderFactory.createBorder(SideBorder.TOP | SideBorder.BOTTOM));
panel.add(scrollPane, BorderLayout.CENTER);
panel.add(createSouthPanel(), BorderLayout.SOUTH);
DataManager.registerDataProvider(
panel,
new DataProvider() {
@Override
public Object getData(@NonNls String dataId) {
if (PlatformDataKeys.PROJECT.is(dataId)) {
return myProject;
}
if (LangDataKeys.PSI_ELEMENT.is(dataId)) {
final Object node =
ContainerUtil.getFirstItem(myAbstractTreeBuilder.getSelectedElements());
if (!(node instanceof FilteringTreeStructure.FilteringNode)) return null;
return getPsi((FilteringTreeStructure.FilteringNode) node);
}
if (LangDataKeys.POSITION_ADJUSTER_POPUP.is(dataId)) {
return myPopup;
}
if (PlatformDataKeys.TREE_EXPANDER.is(dataId)) {
return myTreeExpander;
}
return null;
}
});
return panel;
}
public RegistryUi() {
myContent.setLayout(new BorderLayout(UIUtil.DEFAULT_HGAP, UIUtil.DEFAULT_VGAP));
myModel = new MyTableModel();
myTable = new JBTable(myModel);
myTable.setCellSelectionEnabled(true);
myTable.setEnableAntialiasing(true);
final MyRenderer r = new MyRenderer();
final TableColumn c0 = myTable.getColumnModel().getColumn(0);
c0.setCellRenderer(r);
c0.setMaxWidth(RESTART_ICON.getIconWidth() + 12);
c0.setMinWidth(RESTART_ICON.getIconWidth() + 12);
c0.setHeaderValue(null);
final TableColumn c1 = myTable.getColumnModel().getColumn(1);
c1.setCellRenderer(r);
c1.setHeaderValue("Key");
final TableColumn c2 = myTable.getColumnModel().getColumn(2);
c2.setCellRenderer(r);
c2.setHeaderValue("Value");
c2.setCellEditor(new MyEditor());
myTable.setStriped(true);
myDescriptionLabel = new JTextArea(3, 50);
myDescriptionLabel.setEditable(false);
final JScrollPane label = ScrollPaneFactory.createScrollPane(myDescriptionLabel);
final JPanel descriptionPanel = new JPanel(new BorderLayout());
descriptionPanel.add(label, BorderLayout.CENTER);
descriptionPanel.setBorder(
IdeBorderFactory.createTitledBorder("Description", false, false, true));
myContent.add(ScrollPaneFactory.createScrollPane(myTable), BorderLayout.CENTER);
myContent.add(descriptionPanel, BorderLayout.SOUTH);
myTable
.getSelectionModel()
.addListSelectionListener(
new ListSelectionListener() {
public void valueChanged(ListSelectionEvent e) {
if (e.getValueIsAdjusting()) return;
final int selected = myTable.getSelectedRow();
if (selected != -1) {
final RegistryValue value = myModel.getRegistryValue(selected);
String desc = value.getDescription();
if (value.isRestartRequired()) {
String required = "Requires IDE restart.";
if (desc.endsWith(".")) {
desc += required;
} else {
desc += (". " + required);
}
}
myDescriptionLabel.setText(desc);
} else {
myDescriptionLabel.setText(null);
}
}
});
myRestoreDefaultsAction = new RestoreDefaultsAction();
final DefaultActionGroup tbGroup = new DefaultActionGroup();
tbGroup.add(new EditAction());
tbGroup.add(new RevertAction());
final ActionToolbar tb =
ActionManager.getInstance().createActionToolbar(ActionPlaces.UNKNOWN, tbGroup, true);
tb.setTargetComponent(myTable);
myContent.add(tb.getComponent(), BorderLayout.NORTH);
new TableSpeedSearch(myTable).setComparator(new SpeedSearchComparator(false));
}
/** @author irengrig Date: 2/3/11 Time: 12:04 PM */
public class VcsStructureChooser extends DialogWrapper {
private static final int MAX_FOLDERS = 100;
public static final Border BORDER =
IdeBorderFactory.createBorder(SideBorder.TOP | SideBorder.LEFT);
public static final String CAN_NOT_ADD_TEXT =
"<html>Selected: <font color=red>(You have added "
+ MAX_FOLDERS
+ " elements. No more is allowed.)</font></html>";
@NotNull private final Project myProject;
@NotNull private final List<VirtualFile> myInitialRoots;
@NotNull private final Map<VirtualFile, String> myModulesSet = ContainerUtil.newHashMap();
@NotNull private final Set<VirtualFile> mySelectedFiles = ContainerUtil.newHashSet();
@NotNull private final SelectionManager mySelectionManager;
private Set<VirtualFile> myRoots;
private JLabel mySelectedLabel;
private DefaultMutableTreeNode myRoot;
private Tree myTree;
public VcsStructureChooser(
@NotNull Project project,
String title,
Collection<VirtualFile> initialSelection,
@NotNull List<VirtualFile> initialRoots) {
super(project, true);
setTitle(title);
myProject = project;
myInitialRoots = initialRoots;
mySelectionManager = new SelectionManager(MAX_FOLDERS, 500, MyNodeConverter.getInstance());
init();
mySelectionManager.setSelection(initialSelection);
checkEmpty();
}
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);
}
}
}
}
@NotNull
public Collection<VirtualFile> getSelectedFiles() {
return mySelectedFiles;
}
private void checkEmpty() {
setOKActionEnabled(!mySelectedFiles.isEmpty());
}
@Override
protected String getDimensionServiceKey() {
return "git4idea.history.wholeTree.VcsStructureChooser";
}
@Override
public JComponent getPreferredFocusedComponent() {
return myTree;
}
@Override
protected JComponent createCenterPanel() {
final FileChooserDescriptor descriptor =
FileChooserDescriptorFactory.createAllButJarContentsDescriptor();
calculateRoots();
final ArrayList<VirtualFile> list = new ArrayList<VirtualFile>(myRoots);
final Comparator<VirtualFile> comparator =
new Comparator<VirtualFile>() {
@Override
public int compare(VirtualFile o1, VirtualFile o2) {
final boolean isDir1 = o1.isDirectory();
final boolean isDir2 = o2.isDirectory();
if (isDir1 != isDir2) return isDir1 ? -1 : 1;
final String module1 = myModulesSet.get(o1);
final String path1 = module1 != null ? module1 : o1.getPath();
final String module2 = myModulesSet.get(o2);
final String path2 = module2 != null ? module2 : o2.getPath();
return path1.compareToIgnoreCase(path2);
}
};
descriptor.setRoots(list);
myTree = new Tree();
myTree.setMinimumSize(new Dimension(200, 200));
myTree.setBorder(BORDER);
myTree.setShowsRootHandles(true);
myTree.setRootVisible(true);
myTree.getExpandableItemsHandler().setEnabled(false);
final MyCheckboxTreeCellRenderer cellRenderer =
new MyCheckboxTreeCellRenderer(
mySelectionManager, myModulesSet, myProject, myTree, myRoots);
final FileSystemTreeImpl fileSystemTree =
new FileSystemTreeImpl(
myProject,
descriptor,
myTree,
cellRenderer,
null,
new Convertor<TreePath, String>() {
@Override
public String convert(TreePath o) {
final DefaultMutableTreeNode lastPathComponent =
((DefaultMutableTreeNode) o.getLastPathComponent());
final Object uo = lastPathComponent.getUserObject();
if (uo instanceof FileNodeDescriptor) {
final VirtualFile file = ((FileNodeDescriptor) uo).getElement().getFile();
final String module = myModulesSet.get(file);
if (module != null) return module;
return file == null ? "" : file.getName();
}
return o.toString();
}
});
final AbstractTreeUi ui = fileSystemTree.getTreeBuilder().getUi();
ui.setNodeDescriptorComparator(
new Comparator<NodeDescriptor>() {
@Override
public int compare(NodeDescriptor o1, NodeDescriptor o2) {
if (o1 instanceof FileNodeDescriptor && o2 instanceof FileNodeDescriptor) {
final VirtualFile f1 = ((FileNodeDescriptor) o1).getElement().getFile();
final VirtualFile f2 = ((FileNodeDescriptor) o2).getElement().getFile();
return comparator.compare(f1, f2);
}
return o1.getIndex() - o2.getIndex();
}
});
myRoot = (DefaultMutableTreeNode) myTree.getModel().getRoot();
new ClickListener() {
@Override
public boolean onClick(@NotNull MouseEvent e, int clickCount) {
int row = myTree.getRowForLocation(e.getX(), e.getY());
if (row < 0) return false;
final Object o = myTree.getPathForRow(row).getLastPathComponent();
if (myRoot == o || getFile(o) == null) return false;
Rectangle rowBounds = myTree.getRowBounds(row);
cellRenderer.setBounds(rowBounds);
Rectangle checkBounds = cellRenderer.myCheckbox.getBounds();
checkBounds.setLocation(rowBounds.getLocation());
if (checkBounds.height == 0) checkBounds.height = rowBounds.height;
if (checkBounds.contains(e.getPoint())) {
mySelectionManager.toggleSelection((DefaultMutableTreeNode) o);
myTree.revalidate();
myTree.repaint();
}
return true;
}
}.installOn(myTree);
myTree.addKeyListener(
new KeyAdapter() {
public void keyPressed(KeyEvent e) {
if (e.getKeyCode() == KeyEvent.VK_SPACE) {
TreePath[] paths = myTree.getSelectionPaths();
if (paths == null) return;
for (TreePath path : paths) {
if (path == null) continue;
final Object o = path.getLastPathComponent();
if (myRoot == o || getFile(o) == null) return;
mySelectionManager.toggleSelection((DefaultMutableTreeNode) o);
}
myTree.revalidate();
myTree.repaint();
e.consume();
}
}
});
JBPanel panel = new JBPanel(new BorderLayout());
panel.add(new JBScrollPane(fileSystemTree.getTree()), BorderLayout.CENTER);
mySelectedLabel = new JLabel("");
mySelectedLabel.setBorder(BorderFactory.createEmptyBorder(2, 0, 2, 0));
panel.add(mySelectedLabel, BorderLayout.SOUTH);
mySelectionManager.setSelectionChangeListener(
new PlusMinus<VirtualFile>() {
@Override
public void plus(VirtualFile virtualFile) {
mySelectedFiles.add(virtualFile);
recalculateErrorText();
}
private void recalculateErrorText() {
checkEmpty();
if (mySelectionManager.canAddSelection()) {
mySelectedLabel.setText("");
} else {
mySelectedLabel.setText(CAN_NOT_ADD_TEXT);
}
mySelectedLabel.revalidate();
}
@Override
public void minus(VirtualFile virtualFile) {
mySelectedFiles.remove(virtualFile);
recalculateErrorText();
}
});
return panel;
}
@Nullable
private static VirtualFile getFile(final Object node) {
if (!(((DefaultMutableTreeNode) node).getUserObject() instanceof FileNodeDescriptor))
return null;
final FileNodeDescriptor descriptor =
(FileNodeDescriptor) ((DefaultMutableTreeNode) node).getUserObject();
if (descriptor.getElement().getFile() == null) return null;
return descriptor.getElement().getFile();
}
private static class MyCheckboxTreeCellRenderer extends JPanel implements TreeCellRenderer {
private final WithModulesListCellRenderer myTextRenderer;
public final JCheckBox myCheckbox;
private final SelectionManager mySelectionManager;
private final Map<VirtualFile, String> myModulesSet;
private final Collection<VirtualFile> myRoots;
private final ColoredTreeCellRenderer myColoredRenderer;
private final JLabel myEmpty;
private final JList myFictive;
private MyCheckboxTreeCellRenderer(
final SelectionManager selectionManager,
Map<VirtualFile, String> modulesSet,
final Project project,
final JTree tree,
final Collection<VirtualFile> roots) {
super(new BorderLayout());
mySelectionManager = selectionManager;
myModulesSet = modulesSet;
myRoots = roots;
setBackground(tree.getBackground());
myColoredRenderer =
new ColoredTreeCellRenderer() {
@Override
public void customizeCellRenderer(
JTree tree,
Object value,
boolean selected,
boolean expanded,
boolean leaf,
int row,
boolean hasFocus) {
append(value.toString());
}
};
myFictive = new JBList();
myFictive.setBackground(tree.getBackground());
myFictive.setSelectionBackground(UIUtil.getListSelectionBackground());
myFictive.setSelectionForeground(UIUtil.getListSelectionForeground());
myTextRenderer =
new WithModulesListCellRenderer(project, myModulesSet) {
@Override
protected void putParentPath(Object value, FilePath path, FilePath self) {
if (myRoots.contains(self.getVirtualFile())) {
super.putParentPath(value, path, self);
}
}
};
myTextRenderer.setBackground(tree.getBackground());
myCheckbox = new JCheckBox();
myCheckbox.setBackground(tree.getBackground());
myEmpty = new JLabel("");
add(myCheckbox, BorderLayout.WEST);
add(myTextRenderer, BorderLayout.CENTER);
myCheckbox.setVisible(true);
}
@Override
public Component getTreeCellRendererComponent(
JTree tree,
Object value,
boolean selected,
boolean expanded,
boolean leaf,
int row,
boolean hasFocus) {
invalidate();
final VirtualFile file = getFile(value);
final DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;
if (file == null) {
if (value instanceof DefaultMutableTreeNode) {
final Object uo = node.getUserObject();
if (uo instanceof String) {
myColoredRenderer.getTreeCellRendererComponent(
tree, value, selected, expanded, leaf, row, hasFocus);
return myColoredRenderer;
}
}
return myEmpty;
}
myCheckbox.setVisible(true);
final TreeNodeState state = mySelectionManager.getState(node);
myCheckbox.setEnabled(
TreeNodeState.CLEAR.equals(state) || TreeNodeState.SELECTED.equals(state));
myCheckbox.setSelected(!TreeNodeState.CLEAR.equals(state));
myCheckbox.setOpaque(false);
myCheckbox.setBackground(null);
setBackground(null);
myTextRenderer.getListCellRendererComponent(myFictive, file, 0, selected, hasFocus);
revalidate();
return this;
}
}
private static class MyNodeConverter implements Convertor<DefaultMutableTreeNode, VirtualFile> {
private static final MyNodeConverter ourInstance = new MyNodeConverter();
public static MyNodeConverter getInstance() {
return ourInstance;
}
@Override
public VirtualFile convert(DefaultMutableTreeNode o) {
return ((FileNodeDescriptor) o.getUserObject()).getElement().getFile();
}
}
private static class WithModulesListCellRenderer extends VirtualFileListCellRenderer {
private final Map<VirtualFile, String> myModules;
private WithModulesListCellRenderer(Project project, final Map<VirtualFile, String> modules) {
super(project, true);
myModules = modules;
}
@Override
protected String getName(FilePath path) {
final String module = myModules.get(path.getVirtualFile());
if (module != null) {
return module;
}
return super.getName(path);
}
@Override
protected void renderIcon(FilePath path) {
final String module = myModules.get(path.getVirtualFile());
if (module != null) {
setIcon(PlatformIcons.CONTENT_ROOT_ICON_CLOSED);
} else {
if (path.isDirectory()) {
setIcon(PlatformIcons.DIRECTORY_CLOSED_ICON);
} else {
setIcon(path.getFileType().getIcon());
}
}
}
@Override
protected void putParentPathImpl(Object value, String parentPath, FilePath self) {
append(self.getPath(), SimpleTextAttributes.GRAYED_ATTRIBUTES);
}
}
}
@SuppressWarnings("unchecked")
private void createUIComponents() {
final JBList projectExistLocalesList = new JBList();
final MyExistLocalesListModel existLocalesListModel = new MyExistLocalesListModel();
projectExistLocalesList.setModel(existLocalesListModel);
projectExistLocalesList.setCellRenderer(getLocaleRenderer());
myProjectExistLocalesPanel =
ToolbarDecorator.createDecorator(projectExistLocalesList)
.disableRemoveAction()
.disableUpDownActions()
.createPanel();
myProjectExistLocalesPanel.setBorder(
IdeBorderFactory.createTitledBorder("Project locales", false));
final JBList localesToAddList = new JBList();
final List<Locale> locales;
final List<Locale> restrictedLocales;
if (myResourceBundle == null) {
locales = Collections.singletonList(PropertiesUtil.DEFAULT_LOCALE);
restrictedLocales = Collections.emptyList();
} else {
locales = Collections.emptyList();
restrictedLocales =
ContainerUtil.map(myResourceBundle.getPropertiesFiles(), PropertiesFile::getLocale);
}
myLocalesModel =
new CollectionListModel<Locale>(locales) {
@Override
public void add(@NotNull List<? extends Locale> elements) {
final List<Locale> currentItems = getItems();
elements =
ContainerUtil.filter(
elements,
locale ->
!restrictedLocales.contains(locale) && !currentItems.contains(locale));
super.add(elements);
}
};
localesToAddList.setModel(myLocalesModel);
localesToAddList.setCellRenderer(getLocaleRenderer());
localesToAddList.addFocusListener(
new FocusAdapter() {
@Override
public void focusGained(FocusEvent e) {
projectExistLocalesList.clearSelection();
}
});
projectExistLocalesList.addFocusListener(
new FocusAdapter() {
@Override
public void focusGained(FocusEvent e) {
localesToAddList.clearSelection();
}
});
myNewBundleLocalesPanel =
ToolbarDecorator.createDecorator(localesToAddList)
.setAddAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
final String rawAddedLocales =
Messages.showInputDialog(
myProject,
PropertiesBundle.message(
"create.resource.bundle.dialog.add.locales.validator.message"),
PropertiesBundle.message(
"create.resource.bundle.dialog.add.locales.validator.title"),
null,
null,
new InputValidatorEx() {
@Nullable
@Override
public String getErrorText(String inputString) {
return checkInput(inputString) ? null : "Invalid locales";
}
@Override
public boolean checkInput(String inputString) {
return extractLocalesFromString(inputString) != null;
}
@Override
public boolean canClose(String inputString) {
return checkInput(inputString);
}
});
if (rawAddedLocales != null) {
final List<Locale> locales = extractLocalesFromString(rawAddedLocales);
LOG.assertTrue(locales != null);
myLocalesModel.add(locales);
}
}
})
.setAddActionName("Add locales by suffix")
.disableUpDownActions()
.createPanel();
myNewBundleLocalesPanel.setBorder(IdeBorderFactory.createTitledBorder("Locales to add", false));
myAddLocaleFromExistButton = new JButton(AllIcons.Actions.Forward);
new ClickListener() {
@Override
public boolean onClick(@NotNull MouseEvent event, int clickCount) {
if (clickCount == 1) {
myLocalesModel.add(
ContainerUtil.map(projectExistLocalesList.getSelectedValues(), o -> (Locale) o));
return true;
}
return false;
}
}.installOn(myAddLocaleFromExistButton);
projectExistLocalesList.addListSelectionListener(
new ListSelectionListener() {
@Override
public void valueChanged(ListSelectionEvent e) {
final List<Locale> currentItems = myLocalesModel.getItems();
for (Object o : projectExistLocalesList.getSelectedValues()) {
Locale l = (Locale) o;
if (!restrictedLocales.contains(l) && !currentItems.contains(l)) {
myAddLocaleFromExistButton.setEnabled(true);
return;
}
}
myAddLocaleFromExistButton.setEnabled(false);
}
});
myAddLocaleFromExistButton.setEnabled(false);
myAddAllButton = new JButton("Add All");
new ClickListener() {
@Override
public boolean onClick(@NotNull MouseEvent event, int clickCount) {
if (clickCount == 1) {
myLocalesModel.add(existLocalesListModel.getLocales());
}
return false;
}
}.installOn(myAddAllButton);
}
