private void registerActions() {
// control+tab switches editors
new AnAction() {
@Override
public void actionPerformed(AnActionEvent e) {
if (getEditor1() != null && getEditor2() != null) {
Editor focus =
getEditor1().getContentComponent().hasFocus() ? getEditor2() : getEditor1();
IdeFocusManager.getGlobalInstance().requestFocus(focus.getContentComponent(), true);
focus.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE);
}
}
}.registerCustomShortcutSet(CustomShortcutSet.fromString("control TAB"), myPanel, this);
}
@Override
protected void addToolbarButtons(ToolbarDecorator toolbarDecorator) {
AnActionButton specifyUrlButton =
new AnActionButton(
ProjectBundle.message("sdk.paths.specify.url.button"), IconUtil.getAddLinkIcon()) {
@Override
public void actionPerformed(AnActionEvent e) {
onSpecifyUrlButtonClicked();
}
};
specifyUrlButton.setShortcut(CustomShortcutSet.fromString("alt S"));
specifyUrlButton.addCustomUpdater(
new AnActionButtonUpdater() {
@Override
public boolean isEnabled(AnActionEvent e) {
return myEnabled && !isUrlInserted();
}
});
toolbarDecorator.addExtraAction(specifyUrlButton);
}
private void addCommentActionToEditor(
Editor editor,
String filePath,
ChangeInfo changeInfo,
String revisionId,
Comment.Side commentSide) {
if (editor == null) return;
DefaultActionGroup group = new DefaultActionGroup();
final AddCommentAction addCommentAction =
addCommentActionBuilder
.create(this, changeInfo, revisionId, editor, filePath, commentSide)
.withText("Add Comment")
.withIcon(AllIcons.Toolwindows.ToolWindowMessages)
.get();
addCommentAction.registerCustomShortcutSet(
CustomShortcutSet.fromString("C"), editor.getContentComponent());
group.add(addCommentAction);
PopupHandler.installUnknownPopupHandler(
editor.getContentComponent(), group, ActionManager.getInstance());
}
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 DocumentationComponent(
final DocumentationManager manager, final AnAction[] additionalActions) {
myManager = manager;
myIsEmpty = true;
myIsShown = false;
myEditorPane =
new JEditorPane(UIUtil.HTML_MIME, "") {
@Override
public Dimension getPreferredScrollableViewportSize() {
if (getWidth() == 0 || getHeight() == 0) {
setSize(MAX_WIDTH, MAX_HEIGHT);
}
Insets ins = myEditorPane.getInsets();
View rootView = myEditorPane.getUI().getRootView(myEditorPane);
rootView.setSize(
MAX_WIDTH,
MAX_HEIGHT); // Necessary! Without this line, size will not increase then you go
// from small page to bigger one
int prefHeight = (int) rootView.getPreferredSpan(View.Y_AXIS);
prefHeight +=
ins.bottom
+ ins.top
+ myScrollPane.getHorizontalScrollBar().getMaximumSize().height;
return new Dimension(MAX_WIDTH, Math.max(MIN_HEIGHT, Math.min(MAX_HEIGHT, prefHeight)));
}
{
enableEvents(AWTEvent.KEY_EVENT_MASK);
}
@Override
protected void processKeyEvent(KeyEvent e) {
KeyStroke keyStroke = KeyStroke.getKeyStrokeForEvent(e);
ActionListener listener = myKeyboardActions.get(keyStroke);
if (listener != null) {
listener.actionPerformed(new ActionEvent(DocumentationComponent.this, 0, ""));
e.consume();
return;
}
super.processKeyEvent(e);
}
@Override
protected void paintComponent(Graphics g) {
GraphicsUtil.setupAntialiasing(g);
super.paintComponent(g);
}
};
DataProvider helpDataProvider =
new DataProvider() {
@Override
public Object getData(@NonNls String dataId) {
return PlatformDataKeys.HELP_ID.is(dataId) ? DOCUMENTATION_TOPIC_ID : null;
}
};
myEditorPane.putClientProperty(DataManager.CLIENT_PROPERTY_DATA_PROVIDER, helpDataProvider);
myText = "";
myEditorPane.setEditable(false);
myEditorPane.setBackground(HintUtil.INFORMATION_COLOR);
myEditorPane.setEditorKit(UIUtil.getHTMLEditorKit());
myScrollPane =
new JBScrollPane(myEditorPane) {
@Override
protected void processMouseWheelEvent(MouseWheelEvent e) {
if (!EditorSettingsExternalizable.getInstance().isWheelFontChangeEnabled()
|| !EditorUtil.isChangeFontSize(e)) {
super.processMouseWheelEvent(e);
return;
}
int change = Math.abs(e.getWheelRotation());
boolean increase = e.getWheelRotation() <= 0;
EditorColorsManager colorsManager = EditorColorsManager.getInstance();
EditorColorsScheme scheme = colorsManager.getGlobalScheme();
FontSize newFontSize = scheme.getQuickDocFontSize();
for (; change > 0; change--) {
if (increase) {
newFontSize = newFontSize.larger();
} else {
newFontSize = newFontSize.smaller();
}
}
if (newFontSize == scheme.getQuickDocFontSize()) {
return;
}
scheme.setQuickDocFontSize(newFontSize);
applyFontSize();
setFontSizeSliderSize(newFontSize);
}
};
myScrollPane.setBorder(null);
myScrollPane.putClientProperty(DataManager.CLIENT_PROPERTY_DATA_PROVIDER, helpDataProvider);
final MouseAdapter mouseAdapter =
new MouseAdapter() {
@Override
public void mousePressed(MouseEvent e) {
myManager.requestFocus();
myShowSettingsButton.hideSettings();
}
};
myEditorPane.addMouseListener(mouseAdapter);
Disposer.register(
this,
new Disposable() {
@Override
public void dispose() {
myEditorPane.removeMouseListener(mouseAdapter);
}
});
final FocusAdapter focusAdapter =
new FocusAdapter() {
@Override
public void focusLost(FocusEvent e) {
Component previouslyFocused =
WindowManagerEx.getInstanceEx()
.getFocusedComponent(manager.getProject(getElement()));
if (!(previouslyFocused == myEditorPane)) {
if (myHint != null && !myHint.isDisposed()) myHint.cancel();
}
}
};
myEditorPane.addFocusListener(focusAdapter);
Disposer.register(
this,
new Disposable() {
@Override
public void dispose() {
myEditorPane.removeFocusListener(focusAdapter);
}
});
setLayout(new BorderLayout());
JLayeredPane layeredPane =
new JBLayeredPane() {
@Override
public void doLayout() {
final Rectangle r = getBounds();
for (Component component : getComponents()) {
if (component instanceof JScrollPane) {
component.setBounds(0, 0, r.width, r.height);
} else {
int insets = 2;
Dimension d = component.getPreferredSize();
component.setBounds(r.width - d.width - insets, insets, d.width, d.height);
}
}
}
@Override
public Dimension getPreferredSize() {
Dimension editorPaneSize = myEditorPane.getPreferredScrollableViewportSize();
Dimension controlPanelSize = myControlPanel.getPreferredSize();
return new Dimension(
Math.max(editorPaneSize.width, controlPanelSize.width),
editorPaneSize.height + controlPanelSize.height);
}
};
layeredPane.add(myScrollPane);
layeredPane.setLayer(myScrollPane, 0);
mySettingsPanel = createSettingsPanel();
layeredPane.add(mySettingsPanel);
layeredPane.setLayer(mySettingsPanel, JLayeredPane.POPUP_LAYER);
add(layeredPane, BorderLayout.CENTER);
setOpaque(true);
myScrollPane.setViewportBorder(JBScrollPane.createIndentBorder());
final DefaultActionGroup actions = new DefaultActionGroup();
final BackAction back = new BackAction();
final ForwardAction forward = new ForwardAction();
actions.add(back);
actions.add(forward);
actions.add(myExternalDocAction = new ExternalDocAction());
back.registerCustomShortcutSet(CustomShortcutSet.fromString("LEFT"), this);
forward.registerCustomShortcutSet(CustomShortcutSet.fromString("RIGHT"), this);
myExternalDocAction.registerCustomShortcutSet(CustomShortcutSet.fromString("UP"), this);
if (additionalActions != null) {
for (final AnAction action : additionalActions) {
actions.add(action);
}
}
myToolBar =
ActionManager.getInstance()
.createActionToolbar(ActionPlaces.JAVADOC_TOOLBAR, actions, true);
myControlPanel = new JPanel();
myControlPanel.setLayout(new BorderLayout());
myControlPanel.setBorder(IdeBorderFactory.createBorder(SideBorder.BOTTOM));
JPanel dummyPanel = new JPanel();
myElementLabel = new JLabel();
dummyPanel.setLayout(new BorderLayout());
dummyPanel.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 5));
dummyPanel.add(myElementLabel, BorderLayout.EAST);
myControlPanel.add(myToolBar.getComponent(), BorderLayout.WEST);
myControlPanel.add(dummyPanel, BorderLayout.CENTER);
myControlPanel.add(myShowSettingsButton = new MyShowSettingsButton(), BorderLayout.EAST);
myControlPanelVisible = false;
final HyperlinkListener hyperlinkListener =
new HyperlinkListener() {
@Override
public void hyperlinkUpdate(HyperlinkEvent e) {
HyperlinkEvent.EventType type = e.getEventType();
if (type == HyperlinkEvent.EventType.ACTIVATED) {
manager.navigateByLink(DocumentationComponent.this, e.getDescription());
}
}
};
myEditorPane.addHyperlinkListener(hyperlinkListener);
Disposer.register(
this,
new Disposable() {
@Override
public void dispose() {
myEditorPane.removeHyperlinkListener(hyperlinkListener);
}
});
registerActions();
updateControlState();
}
@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 DirDiffPanel(DirDiffTableModel model, DirDiffWindow wnd) {
myModel = model;
myDiffWindow = wnd;
mySourceDirField.setText(model.getSourceDir().getPath());
myTargetDirField.setText(model.getTargetDir().getPath());
mySourceDirField.setBorder(JBUI.Borders.emptyRight(8));
myTargetDirField.setBorder(JBUI.Borders.emptyRight(12));
mySourceDirLabel.setIcon(model.getSourceDir().getIcon());
myTargetDirLabel.setIcon(model.getTargetDir().getIcon());
myTargetDirLabel.setBorder(JBUI.Borders.emptyLeft(8));
myModel.setTable(myTable);
myModel.setPanel(this);
Disposer.register(this, myModel);
myTable.setModel(myModel);
new TableSpeedSearch(myTable);
final DirDiffTableCellRenderer renderer = new DirDiffTableCellRenderer();
myTable.setExpandableItemsEnabled(false);
myTable.setDefaultRenderer(Object.class, renderer);
myTable.getSelectionModel().setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
final Project project = myModel.getProject();
myTable
.getSelectionModel()
.addListSelectionListener(
new ListSelectionListener() {
@Override
public void valueChanged(ListSelectionEvent e) {
final int lastIndex = e.getLastIndex();
final int firstIndex = e.getFirstIndex();
final DirDiffElementImpl last = myModel.getElementAt(lastIndex);
final DirDiffElementImpl first = myModel.getElementAt(firstIndex);
if (last == null || first == null) {
update(false);
return;
}
if (last.isSeparator()) {
final int ind = lastIndex + ((lastIndex < firstIndex) ? 1 : -1);
myTable.getSelectionModel().addSelectionInterval(ind, ind);
} else if (first.isSeparator()) {
final int ind = firstIndex + ((firstIndex < lastIndex) ? 1 : -1);
myTable.getSelectionModel().addSelectionInterval(ind, ind);
} else {
update(false);
}
myDiffWindow.setTitle(myModel.getTitle());
}
});
if (model.isOperationsEnabled()) {
new AnAction("Change diff operation") {
@Override
public void actionPerformed(AnActionEvent e) {
changeOperationForSelection();
}
}.registerCustomShortcutSet(CustomShortcutSet.fromString("SPACE"), myTable);
new ClickListener() {
@Override
public boolean onClick(@NotNull MouseEvent e, int clickCount) {
if (e.getButton() == MouseEvent.BUTTON3) return false;
if (myTable.getRowCount() > 0) {
final int row = myTable.rowAtPoint(e.getPoint());
final int col = myTable.columnAtPoint(e.getPoint());
if (row != -1 && col == ((myTable.getColumnCount() - 1) / 2)) {
changeOperationForSelection();
}
}
return true;
}
}.installOn(myTable);
}
myTable.addKeyListener(
new KeyAdapter() {
@Override
public void keyPressed(KeyEvent e) {
final int keyCode = e.getKeyCode();
int row;
if (keyCode == KeyEvent.VK_DOWN) {
row = getNextRow();
} else if (keyCode == KeyEvent.VK_UP) {
row = getPrevRow();
} else {
row = -1;
}
if (row != -1) {
selectRow(row, e.isShiftDown());
e.consume();
}
}
});
final TableColumnModel columnModel = myTable.getColumnModel();
final TableColumn operationColumn =
columnModel.getColumn((columnModel.getColumnCount() - 1) / 2);
operationColumn.setMaxWidth(JBUI.scale(25));
operationColumn.setMinWidth(JBUI.scale(25));
for (int i = 0; i < columnModel.getColumnCount(); i++) {
final String name = myModel.getColumnName(i);
final TableColumn column = columnModel.getColumn(i);
if (DirDiffTableModel.COLUMN_DATE.equals(name)) {
column.setMaxWidth(JBUI.scale(90));
column.setMinWidth(JBUI.scale(90));
} else if (DirDiffTableModel.COLUMN_SIZE.equals(name)) {
column.setMaxWidth(JBUI.scale(120));
column.setMinWidth(JBUI.scale(120));
}
}
final DirDiffToolbarActions actions = new DirDiffToolbarActions(myModel, myDiffPanel);
final ActionManager actionManager = ActionManager.getInstance();
final ActionToolbar toolbar = actionManager.createActionToolbar("DirDiff", actions, true);
registerCustomShortcuts(actions, myTable);
myToolBarPanel.add(toolbar.getComponent(), BorderLayout.CENTER);
final JBLabel label =
new JBLabel(
"Use Space button or mouse click to change operation for the selected elements."
+ " Enter to perform.",
SwingConstants.CENTER);
label.setForeground(UIUtil.getInactiveTextColor());
UIUtil.applyStyle(UIUtil.ComponentStyle.MINI, label);
DataManager.registerDataProvider(myFilesPanel, this);
myTable.addMouseListener(
new PopupHandler() {
@Override
public void invokePopup(Component comp, int x, int y) {
final JPopupMenu popupMenu =
actionManager
.createActionPopupMenu(
"DirDiffPanel", (ActionGroup) actionManager.getAction("DirDiffMenu"))
.getComponent();
popupMenu.show(comp, x, y);
}
});
myFilesPanel.add(label, BorderLayout.SOUTH);
final JBLoadingPanel loadingPanel = new JBLoadingPanel(new BorderLayout(), wnd.getDisposable());
loadingPanel.addListener(
new JBLoadingPanelListener.Adapter() {
boolean showHelp = true;
@Override
public void onLoadingFinish() {
if (showHelp && myModel.isOperationsEnabled() && myModel.getRowCount() > 0) {
final long count =
PropertiesComponent.getInstance().getOrInitLong("dir.diff.space.button.info", 0);
if (count < 3) {
JBPopupFactory.getInstance()
.createBalloonBuilder(new JLabel(" Use Space button to change operation"))
.setFadeoutTime(5000)
.setContentInsets(JBUI.insets(15))
.createBalloon()
.show(
new RelativePoint(myTable, new Point(myTable.getWidth() / 2, 0)),
Balloon.Position.above);
PropertiesComponent.getInstance()
.setValue("dir.diff.space.button.info", String.valueOf(count + 1));
}
}
showHelp = false;
}
});
loadingPanel.add(myComponent, BorderLayout.CENTER);
myTable.putClientProperty(myModel.DECORATOR, loadingPanel);
myTable.addComponentListener(
new ComponentAdapter() {
@Override
public void componentShown(ComponentEvent e) {
myTable.removeComponentListener(this);
myModel.reloadModel(false);
}
});
myRootPanel.removeAll();
myRootPanel.add(loadingPanel, BorderLayout.CENTER);
myFilter =
new FilterComponent("dir.diff.filter", 15, false) {
@Override
public void filter() {
fireFilterUpdated();
}
@Override
protected void onEscape(KeyEvent e) {
e.consume();
focusTable();
}
@Override
protected JComponent getPopupLocationComponent() {
return UIUtil.findComponentOfType(
super.getPopupLocationComponent(), JTextComponent.class);
}
};
myModel.addModelListener(
new DirDiffModelListener() {
@Override
public void updateStarted() {
myFilter.setEnabled(false);
}
@Override
public void updateFinished() {
myFilter.setEnabled(true);
}
});
myFilter.getTextEditor().setColumns(10);
myFilter.setFilter(myModel.getSettings().getFilter());
// oldFilter = myFilter.getText();
oldFilter = myFilter.getFilter();
myFilterPanel.add(myFilter, BorderLayout.CENTER);
myFilterLabel.setLabelFor(myFilter);
final Callable<DiffElement> srcChooser = myModel.getSourceDir().getElementChooser(project);
final Callable<DiffElement> trgChooser = myModel.getTargetDir().getElementChooser(project);
mySourceDirField.setEditable(false);
myTargetDirField.setEditable(false);
if (srcChooser != null && myModel.getSettings().enableChoosers) {
mySourceDirField.setButtonEnabled(true);
mySourceDirField.addActionListener(
new AbstractAction() {
@Override
public void actionPerformed(ActionEvent e) {
try {
final Callable<DiffElement> chooser =
myModel.getSourceDir().getElementChooser(project);
if (chooser == null) return;
final DiffElement newElement = chooser.call();
if (newElement != null) {
if (!StringUtil.equals(mySourceDirField.getText(), newElement.getPath())) {
myModel.setSourceDir(newElement);
mySourceDirField.setText(newElement.getPath());
String shortcutsText =
KeymapUtil.getShortcutsText(
RefreshDirDiffAction.REFRESH_SHORTCUT.getShortcuts());
myModel.clearWithMessage(
"Source or Target has been changed."
+ " Please run Refresh ("
+ shortcutsText
+ ")");
}
}
} catch (Exception ignored) {
}
}
});
} else {
Dimension preferredSize = mySourceDirField.getPreferredSize();
mySourceDirField.setButtonEnabled(false);
mySourceDirField.getButton().setVisible(false);
mySourceDirField.setPreferredSize(preferredSize);
}
if (trgChooser != null && myModel.getSettings().enableChoosers) {
myTargetDirField.setButtonEnabled(true);
myTargetDirField.addActionListener(
new AbstractAction() {
@Override
public void actionPerformed(ActionEvent e) {
try {
final Callable<DiffElement> chooser =
myModel.getTargetDir().getElementChooser(project);
if (chooser == null) return;
final DiffElement newElement = chooser.call();
if (newElement != null) {
myModel.setTargetDir(newElement);
myTargetDirField.setText(newElement.getPath());
}
} catch (Exception ignored) {
}
}
});
} else {
Dimension preferredSize = myTargetDirField.getPreferredSize();
myTargetDirField.setButtonEnabled(false);
myTargetDirField.getButton().setVisible(false);
myTargetDirField.setPreferredSize(preferredSize);
}
myDiffRequestProcessor = new MyDiffRequestProcessor(project);
Disposer.register(this, myDiffRequestProcessor);
myDiffPanel.add(myDiffRequestProcessor.getComponent(), BorderLayout.CENTER);
myPrevNextDifferenceIterable = new MyPrevNextDifferenceIterable();
}
/** @author Konstantin Bulenkov */
public class UpDownHandler {
private static final CustomShortcutSet UP_KEY = CustomShortcutSet.fromString("UP");
private static final CustomShortcutSet DOWN_KEY = CustomShortcutSet.fromString("DOWN");
private UpDownHandler() {}
public static void register(JComponent input, final JComponent affectedComponent) {
register(input, affectedComponent, true);
}
public static void register(
JComponent input, final JComponent affectedComponent, boolean registerOnBothComponents) {
final SelectionMover mover = new SelectionMover(affectedComponent);
final AnAction up =
new AnAction("Up") {
@Override
public void actionPerformed(AnActionEvent e) {
mover.move(-1);
}
};
up.registerCustomShortcutSet(UP_KEY, input);
final AnAction down =
new AnAction("Down") {
@Override
public void actionPerformed(AnActionEvent e) {
mover.move(1);
}
};
down.registerCustomShortcutSet(DOWN_KEY, input);
if (registerOnBothComponents) {
up.registerCustomShortcutSet(UP_KEY, affectedComponent);
down.registerCustomShortcutSet(DOWN_KEY, affectedComponent);
}
}
private static class SelectionMover {
private JComboBox myCombo;
private JList myList;
private SelectionMover(JComponent comp) {
if (comp instanceof JComboBox) {
myCombo = (JComboBox) comp;
} else if (comp instanceof JList) {
myList = (JList) comp;
}
}
void move(int direction) {
int index = -1;
int size = 0;
if (myCombo != null) {
index = myCombo.getSelectedIndex();
size = myCombo.getModel().getSize();
} else if (myList != null) {
index = myList.getSelectedIndex();
size = myList.getModel().getSize();
}
if (index == -1 || size == 0) return;
index += direction;
if (index == size) {
if (!UISettings.getInstance().CYCLE_SCROLLING) return;
index = 0;
} else if (index == -1) {
if (!UISettings.getInstance().CYCLE_SCROLLING) return;
index = size - 1;
}
if (myCombo != null) {
myCombo.setSelectedIndex(index);
} else if (myList != null) {
myList.setSelectedIndex(index);
}
}
}
}