private void layoutPanel() {
if (myUsagePreviewPanel != null) {
Disposer.dispose(myUsagePreviewPanel);
}
removeAll();
JScrollPane pane = ScrollPaneFactory.createScrollPane(myTree);
if (isPreview()) {
pane.setBorder(IdeBorderFactory.createBorder(SideBorder.LEFT | SideBorder.RIGHT));
boolean vertical =
myToolWindow.getAnchor() == ToolWindowAnchor.LEFT
|| myToolWindow.getAnchor() == ToolWindowAnchor.RIGHT;
Splitter splitter =
new Splitter(
vertical, UsageViewSettings.getInstance().PREVIEW_USAGES_SPLITTER_PROPORTIONS);
splitter.setFirstComponent(pane);
myUsagePreviewPanel = new UsagePreviewPanel(myProject, new UsageViewPresentation());
myUsagePreviewPanel.setBorder(IdeBorderFactory.createBorder(SideBorder.LEFT));
Disposer.register(this, myUsagePreviewPanel);
splitter.setSecondComponent(myUsagePreviewPanel);
add(splitter, BorderLayout.CENTER);
} else {
pane.setBorder(IdeBorderFactory.createBorder(SideBorder.LEFT));
add(pane, BorderLayout.CENTER);
}
add(createToolbar().getComponent(), BorderLayout.WEST);
myTree.getParent().setBackground(UIManager.getColor("Tree.background"));
revalidate();
}
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();
}
@Override
public VcsDependentHistoryComponents getUICustomization(
final VcsHistorySession session, JComponent forShortcutRegistration) {
final ColumnInfo[] columns;
final Consumer<VcsFileRevision> listener;
final JComponent addComp;
if (((SvnHistorySession) session).isHaveMergeSources()) {
final MergeSourceColumnInfo mergeSourceColumn =
new MergeSourceColumnInfo((SvnHistorySession) session);
columns = new ColumnInfo[] {new CopyFromColumnInfo(), mergeSourceColumn};
final JPanel panel = new JPanel(new BorderLayout());
final JTextArea field = new JTextArea();
field.setEditable(false);
field.setBackground(UIUtil.getComboBoxDisabledBackground());
field.setWrapStyleWord(true);
listener =
new Consumer<VcsFileRevision>() {
@Override
public void consume(VcsFileRevision vcsFileRevision) {
field.setText(mergeSourceColumn.getText(vcsFileRevision));
}
};
final MergeSourceDetailsAction sourceAction = new MergeSourceDetailsAction();
sourceAction.registerSelf(forShortcutRegistration);
JPanel fieldPanel =
new ToolbarDecorator() {
@Override
protected JComponent getComponent() {
return field;
}
@Override
protected void updateButtons() {}
@Override
protected void installDnDSupport() {}
@Override
protected boolean isModelEditable() {
return false;
}
}.initPosition().addExtraAction(AnActionButton.fromAction(sourceAction)).createPanel();
fieldPanel.setBorder(IdeBorderFactory.createBorder(SideBorder.LEFT | SideBorder.TOP));
panel.add(fieldPanel, BorderLayout.CENTER);
panel.add(new JLabel("Merge Sources:"), BorderLayout.NORTH);
addComp = panel;
} else {
columns = new ColumnInfo[] {new CopyFromColumnInfo()};
addComp = null;
listener = null;
}
return new VcsDependentHistoryComponents(columns, listener, addComp);
}
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));
}
@NotNull
protected List<Pair<String, JPanel>> createAdditionalPanels() {
// this method is invoked before constructor body
myExceptionsModel = new ExceptionsTableModel(myMethod.getMethod().getThrowsList());
myExceptionsModel.setTypeInfos(myMethod.getMethod());
final JBTable table = new JBTable(myExceptionsModel);
table.setStriped(true);
table.setRowHeight(20);
table
.getColumnModel()
.getColumn(0)
.setCellRenderer(new CodeFragmentTableCellRenderer(myProject));
final JavaCodeFragmentTableCellEditor cellEditor =
new JavaCodeFragmentTableCellEditor(myProject);
cellEditor.addDocumentListener(
new DocumentAdapter() {
@Override
public void documentChanged(DocumentEvent e) {
final int row = table.getSelectedRow();
final int col = table.getSelectedColumn();
myExceptionsModel.setValueAt(cellEditor.getCellEditorValue(), row, col);
updateSignature();
}
});
table.getColumnModel().getColumn(0).setCellEditor(cellEditor);
table.getSelectionModel().setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
table.getSelectionModel().setSelectionInterval(0, 0);
table.setSurrendersFocusOnKeystroke(true);
myPropExceptionsButton =
new AnActionButton(
RefactoringBundle.message("changeSignature.propagate.exceptions.title"),
null,
PlatformIcons.NEW_EXCEPTION) {
@Override
public void actionPerformed(AnActionEvent e) {
final Ref<JavaCallerChooser> chooser = new Ref<JavaCallerChooser>();
Consumer<Set<PsiMethod>> callback =
new Consumer<Set<PsiMethod>>() {
@Override
public void consume(Set<PsiMethod> psiMethods) {
myMethodsToPropagateExceptions = psiMethods;
myExceptionPropagationTree = chooser.get().getTree();
}
};
chooser.set(
new JavaCallerChooser(
myMethod.getMethod(),
myProject,
RefactoringBundle.message("changeSignature.exception.caller.chooser"),
myExceptionPropagationTree,
callback));
chooser.get().show();
}
};
myPropExceptionsButton.setShortcut(CustomShortcutSet.fromString("alt X"));
final JPanel panel =
ToolbarDecorator.createDecorator(table)
.addExtraAction(myPropExceptionsButton)
.createPanel();
panel.setBorder(IdeBorderFactory.createEmptyBorder(0));
myExceptionsModel.addTableModelListener(mySignatureUpdater);
final ArrayList<Pair<String, JPanel>> result = new ArrayList<Pair<String, JPanel>>();
final String message =
RefactoringBundle.message("changeSignature.exceptions.panel.border.title");
result.add(Pair.create(message, panel));
return result;
}
public VcsDependentHistoryComponents getUICustomization(
final VcsHistorySession session, JComponent forShortcutRegistration) {
final ColumnInfo[] columns;
final Consumer<VcsFileRevision> listener;
final JComponent addComp;
if (((MyHistorySession) session).isSupports15()) {
final MergeSourceColumnInfo mergeSourceColumn =
new MergeSourceColumnInfo((MyHistorySession) session);
columns = new ColumnInfo[] {new CopyFromColumnInfo(), mergeSourceColumn};
final JTextArea field = new JTextArea();
field.setEditable(false);
field.setBackground(UIUtil.getComboBoxDisabledBackground());
field.setWrapStyleWord(true);
listener =
new Consumer<VcsFileRevision>() {
public void consume(VcsFileRevision vcsFileRevision) {
field.setText(mergeSourceColumn.getText(vcsFileRevision));
}
};
final JPanel panel = new JPanel(new GridBagLayout());
final GridBagConstraints gb =
new GridBagConstraints(
0,
0,
1,
1,
0,
0,
GridBagConstraints.WEST,
GridBagConstraints.NONE,
new Insets(0, 0, 0, 0),
0,
0);
final JLabel mergeLabel = new JLabel("Merge Sources:");
final MergeSourceDetailsAction sourceAction = new MergeSourceDetailsAction();
sourceAction.registerSelf(forShortcutRegistration);
final DefaultActionGroup group = new DefaultActionGroup();
group.add(sourceAction);
final JComponent toolbar =
ActionManager.getInstance()
.createActionToolbar(ActionPlaces.UNKNOWN, group, true)
.getComponent();
panel.add(mergeLabel, gb);
++gb.gridx;
gb.insets.left = 10;
gb.anchor = GridBagConstraints.NORTHWEST;
panel.add(toolbar, gb);
++gb.gridy;
gb.insets.left = 0;
gb.gridx = 0;
gb.gridwidth = 2;
gb.weightx = gb.weighty = 1;
gb.fill = GridBagConstraints.BOTH;
JScrollPane pane = ScrollPaneFactory.createScrollPane(field);
pane.setBorder(IdeBorderFactory.createBorder(SideBorder.LEFT | SideBorder.TOP));
panel.add(pane, gb);
addComp = panel;
} else {
columns = new ColumnInfo[] {new CopyFromColumnInfo()};
addComp = null;
listener = null;
}
return new VcsDependentHistoryComponents(columns, listener, addComp);
}
/** @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);
}
}
}
private JComponent buildTopPanel(boolean enablePipette) throws ParseException {
final JPanel result = new JPanel(new BorderLayout());
final JPanel previewPanel = new JPanel(new BorderLayout());
if (enablePipette && myPicker != null) {
final JButton pipette = new JButton();
pipette.setUI(new BasicButtonUI());
pipette.setRolloverEnabled(true);
pipette.setIcon(AllIcons.Ide.Pipette);
pipette.setBorder(IdeBorderFactory.createEmptyBorder());
pipette.setRolloverIcon(AllIcons.Ide.Pipette_rollover);
pipette.setFocusable(false);
pipette.addActionListener(
new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
myPicker.setInitialColor(getColor());
myPicker.show();
}
});
previewPanel.add(pipette, BorderLayout.WEST);
}
myPreviewComponent = new ColorPreviewComponent();
previewPanel.add(myPreviewComponent, BorderLayout.CENTER);
result.add(previewPanel, BorderLayout.NORTH);
final JPanel rgbPanel = new JPanel();
rgbPanel.setLayout(new BoxLayout(rgbPanel, BoxLayout.X_AXIS));
if (!UIUtil.isUnderAquaLookAndFeel()) {
myR_after.setPreferredSize(new Dimension(14, -1));
myG_after.setPreferredSize(new Dimension(14, -1));
myB_after.setPreferredSize(new Dimension(14, -1));
}
rgbPanel.setBorder(BorderFactory.createEmptyBorder(10, 0, 0, 0));
rgbPanel.add(myR);
rgbPanel.add(myRed);
if (!UIUtil.isUnderAquaLookAndFeel()) rgbPanel.add(myR_after);
rgbPanel.add(Box.createHorizontalStrut(2));
rgbPanel.add(myG);
rgbPanel.add(myGreen);
if (!UIUtil.isUnderAquaLookAndFeel()) rgbPanel.add(myG_after);
rgbPanel.add(Box.createHorizontalStrut(2));
rgbPanel.add(myB);
rgbPanel.add(myBlue);
if (!UIUtil.isUnderAquaLookAndFeel()) rgbPanel.add(myB_after);
rgbPanel.add(Box.createHorizontalStrut(2));
rgbPanel.add(myFormat);
result.add(rgbPanel, BorderLayout.WEST);
final JPanel hexPanel = new JPanel();
hexPanel.setLayout(new BoxLayout(hexPanel, BoxLayout.X_AXIS));
hexPanel.setBorder(BorderFactory.createEmptyBorder(10, 0, 0, 0));
hexPanel.add(new JLabel("#"));
hexPanel.add(myHex);
result.add(hexPanel, BorderLayout.EAST);
return result;
}
@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);
}
public SearchTextField(boolean historyEnabled) {
super(new BorderLayout());
myModel = new MyModel();
myTextField =
new TextFieldWithProcessing() {
@Override
public void processKeyEvent(final KeyEvent e) {
if (preprocessEventForTextField(e)) return;
super.processKeyEvent(e);
}
@Override
public void setBackground(final Color bg) {
super.setBackground(bg);
if (!hasIconsOutsideOfTextField()) {
if (myClearFieldLabel != null) {
myClearFieldLabel.setBackground(bg);
}
}
if (myToggleHistoryLabel != null) {
myToggleHistoryLabel.setBackground(bg);
}
}
};
myTextField.setColumns(15);
myTextField.addFocusListener(
new FocusAdapter() {
@Override
public void focusLost(FocusEvent e) {
onFocusLost();
super.focusLost(e);
}
@Override
public void focusGained(FocusEvent e) {
onFocusGained();
super.focusGained(e);
}
});
add(myTextField, BorderLayout.CENTER);
myTextField.addKeyListener(
new KeyAdapter() {
@Override
public void keyPressed(KeyEvent e) {
if (e.getKeyCode() == KeyEvent.VK_DOWN) {
if (hasNativeLeopardSearchControl() && myNativeSearchPopup != null) {
myNativeSearchPopup.show(myTextField, 5, myTextField.getHeight());
} else if (myPopup == null || !myPopup.isVisible()) {
showPopup();
}
}
}
});
if (hasNativeLeopardSearchControl() || UIUtil.isUnderDarcula()) {
myTextField.putClientProperty("JTextField.variant", "search");
}
if (hasNativeLeopardSearchControl()) {
if (historyEnabled) {
myNativeSearchPopup = new JBPopupMenu();
myNoItems = new JBMenuItem("No recent searches");
myNoItems.setEnabled(false);
updateMenu();
myTextField.putClientProperty("JTextField.Search.FindPopup", myNativeSearchPopup);
}
} else {
myToggleHistoryLabel = new JLabel(AllIcons.Actions.Search);
myToggleHistoryLabel.setOpaque(true);
myToggleHistoryLabel.addMouseListener(
new MouseAdapter() {
public void mousePressed(MouseEvent e) {
togglePopup();
}
});
if (historyEnabled) {
add(myToggleHistoryLabel, BorderLayout.WEST);
}
myClearFieldLabel =
new JLabel(
UIUtil.isUnderDarcula() ? AllIcons.Actions.Clean : AllIcons.Actions.CleanLight);
myClearFieldLabel.setOpaque(true);
add(myClearFieldLabel, BorderLayout.EAST);
myClearFieldLabel.addMouseListener(
new MouseAdapter() {
public void mousePressed(MouseEvent e) {
myTextField.setText("");
onFieldCleared();
}
});
if (!hasIconsOutsideOfTextField()) {
final Border originalBorder;
if (SystemInfo.isMac) {
originalBorder = BorderFactory.createLoweredBevelBorder();
} else {
originalBorder = myTextField.getBorder();
}
myToggleHistoryLabel.setBackground(myTextField.getBackground());
myClearFieldLabel.setBackground(myTextField.getBackground());
setBorder(
new CompoundBorder(IdeBorderFactory.createEmptyBorder(2, 0, 2, 0), originalBorder));
myTextField.setOpaque(true);
myTextField.setBorder(IdeBorderFactory.createEmptyBorder(0, 5, 0, 5));
} else {
setBorder(IdeBorderFactory.createEmptyBorder(2, 0, 2, 0));
}
}
if (ApplicationManager.getApplication() != null) { // tests
final ActionManager actionManager = ActionManager.getInstance();
if (actionManager != null) {
final AnAction clearTextAction = actionManager.getAction(IdeActions.ACTION_CLEAR_TEXT);
if (clearTextAction.getShortcutSet().getShortcuts().length == 0) {
clearTextAction.registerCustomShortcutSet(CommonShortcuts.ESCAPE, this);
}
}
}
}
