public void reset() {
myNoProxyRb.setSelected(true); // default
HttpConfigurable httpConfigurable = myHttpConfigurable;
myAutoDetectProxyRb.setSelected(httpConfigurable.USE_PROXY_PAC);
myPacUrlCheckBox.setSelected(httpConfigurable.USE_PAC_URL);
myPacUrlTextField.setText(httpConfigurable.PAC_URL);
myUseHTTPProxyRb.setSelected(httpConfigurable.USE_HTTP_PROXY);
myProxyAuthCheckBox.setSelected(httpConfigurable.PROXY_AUTHENTICATION);
enableProxy(httpConfigurable.USE_HTTP_PROXY);
myProxyLoginTextField.setText(httpConfigurable.PROXY_LOGIN);
myProxyPasswordTextField.setText(httpConfigurable.getPlainProxyPassword());
myProxyPortTextField.setText(Integer.toString(httpConfigurable.PROXY_PORT));
myProxyHostTextField.setText(httpConfigurable.PROXY_HOST);
myProxyExceptions.setText(httpConfigurable.PROXY_EXCEPTIONS);
myRememberProxyPasswordCheckBox.setSelected(httpConfigurable.KEEP_PROXY_PASSWORD);
mySocks.setSelected(httpConfigurable.PROXY_TYPE_IS_SOCKS);
myHTTP.setSelected(!httpConfigurable.PROXY_TYPE_IS_SOCKS);
final boolean showError = !StringUtil.isEmptyOrSpaces(httpConfigurable.LAST_ERROR);
myErrorLabel.setVisible(showError);
myErrorLabel.setText(showError ? errorText(httpConfigurable.LAST_ERROR) : "");
final String oldStyleText =
CommonProxy.getMessageFromProps(CommonProxy.getOldStyleProperties());
myOtherWarning.setVisible(oldStyleText != null);
if (oldStyleText != null) {
myOtherWarning.setText(oldStyleText);
myOtherWarning.setUI(new MultiLineLabelUI());
myOtherWarning.setIcon(Messages.getWarningIcon());
}
}
private void addErrorMessage(final FixableMessageInfo message, Icon icon) {
if (message.myLinkText.length() > 0 || message.myAfterLinkText.length() > 0) {
HyperlinkLabel warnLabel = new HyperlinkLabel();
warnLabel.setOpaque(false);
warnLabel.setHyperlinkText(
message.myBeforeLinkText, message.myLinkText, message.myAfterLinkText);
warnLabel.setIcon(icon);
if (message.myQuickFix != null) {
warnLabel.addHyperlinkListener(
new HyperlinkListener() {
public void hyperlinkUpdate(final HyperlinkEvent e) {
if (e.getEventType() == HyperlinkEvent.EventType.ACTIVATED) {
message.myQuickFix.run();
}
}
});
}
myErrorMessages.add(warnLabel);
} else {
JBLabel warnLabel = new JBLabel();
warnLabel.setOpaque(false);
warnLabel.setText(
"<html><body>" + message.myBeforeLinkText.replace("\n", "<br>") + "</body></html>");
warnLabel.setIcon(icon);
myErrorMessages.add(warnLabel);
}
if (message.myAdditionalFixes != null && message.myAdditionalFixes.size() > 0) {
JPanel fixesPanel = new JPanel(new FlowLayout(FlowLayout.LEFT, 5, 0));
fixesPanel.setBorder(IdeBorderFactory.createEmptyBorder(3, 0, 10, 0));
fixesPanel.setOpaque(false);
fixesPanel.add(Box.createHorizontalStrut(icon.getIconWidth()));
for (Pair<String, Runnable> pair : message.myAdditionalFixes) {
HyperlinkLabel fixLabel = new HyperlinkLabel();
fixLabel.setOpaque(false);
fixLabel.setHyperlinkText(pair.getFirst());
final Runnable fix = pair.getSecond();
fixLabel.addHyperlinkListener(
new HyperlinkListener() {
@Override
public void hyperlinkUpdate(HyperlinkEvent e) {
if (e.getEventType() == HyperlinkEvent.EventType.ACTIVATED) {
fix.run();
}
}
});
fixesPanel.add(fixLabel);
}
myErrorMessages.add(fixesPanel);
}
}
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();
}
public HTTPProxySettingsPanel(final HttpConfigurable httpConfigurable) {
final ButtonGroup group = new ButtonGroup();
group.add(myUseHTTPProxyRb);
group.add(myAutoDetectProxyRb);
group.add(myNoProxyRb);
myNoProxyRb.setSelected(true);
final ButtonGroup proxyTypeGroup = new ButtonGroup();
proxyTypeGroup.add(myHTTP);
proxyTypeGroup.add(mySocks);
myHTTP.setSelected(true);
myProxyExceptions.setBorder(UIUtil.getTextFieldBorder());
final Boolean property = Boolean.getBoolean(JavaProxyProperty.USE_SYSTEM_PROXY);
mySystemProxyDefined.setVisible(Boolean.TRUE.equals(property));
if (Boolean.TRUE.equals(property)) {
mySystemProxyDefined.setIcon(Messages.getWarningIcon());
mySystemProxyDefined.setFont(mySystemProxyDefined.getFont().deriveFont(Font.BOLD));
mySystemProxyDefined.setUI(new MultiLineLabelUI());
}
myProxyAuthCheckBox.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
enableProxyAuthentication(myProxyAuthCheckBox.isSelected());
}
});
myPacUrlCheckBox.addActionListener(
new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
myPacUrlTextField.setEnabled(myPacUrlCheckBox.isSelected());
}
});
final ActionListener listener =
new ActionListener() {
public void actionPerformed(ActionEvent e) {
enableProxy(myUseHTTPProxyRb.isSelected());
}
};
myUseHTTPProxyRb.addActionListener(listener);
myAutoDetectProxyRb.addActionListener(listener);
myNoProxyRb.addActionListener(listener);
myHttpConfigurable = httpConfigurable;
myClearPasswordsButton.addActionListener(
new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
myHttpConfigurable.clearGenericPasswords();
Messages.showMessageDialog(
myMainPanel,
"Proxy passwords were cleared.",
"Auto-detected proxy",
Messages.getInformationIcon());
}
});
if (HttpConfigurable.getInstance() != null) {
myCheckButton.addActionListener(
new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
final String title = "Check Proxy Settings";
final String answer =
Messages.showInputDialog(
myMainPanel,
"Warning: your settings will be saved.\n\nEnter any URL to check connection to:",
title,
Messages.getQuestionIcon(),
"http://",
null);
if (!StringUtil.isEmptyOrSpaces(answer)) {
apply();
final HttpConfigurable instance = HttpConfigurable.getInstance();
final AtomicReference<IOException> exc = new AtomicReference<IOException>();
myCheckButton.setEnabled(false);
myCheckButton.setText("Check connection (in progress...)");
myConnectionCheckInProgress = true;
final Application application = ApplicationManager.getApplication();
application.executeOnPooledThread(
new Runnable() {
@Override
public void run() {
HttpURLConnection connection = null;
try {
// already checked for null above
//noinspection ConstantConditions
connection = instance.openHttpConnection(answer);
connection.setReadTimeout(3 * 1000);
connection.setConnectTimeout(3 * 1000);
connection.connect();
final int code = connection.getResponseCode();
if (HttpURLConnection.HTTP_OK != code) {
exc.set(new IOException("Error code: " + code));
}
} catch (IOException e1) {
exc.set(e1);
} finally {
if (connection != null) {
connection.disconnect();
}
}
//noinspection SSBasedInspection
SwingUtilities.invokeLater(
new Runnable() {
@Override
public void run() {
myConnectionCheckInProgress = false;
reset(); // since password might have been set
Component parent = null;
if (myMainPanel.isShowing()) {
parent = myMainPanel;
myCheckButton.setText("Check connection");
myCheckButton.setEnabled(canEnableConnectionCheck());
} else {
final IdeFrame frame =
IdeFocusManager.findInstance().getLastFocusedFrame();
if (frame == null) {
return;
}
parent = frame.getComponent();
}
//noinspection ThrowableResultOfMethodCallIgnored
final IOException exception = exc.get();
if (exception == null) {
Messages.showMessageDialog(
parent,
"Connection successful",
title,
Messages.getInformationIcon());
} else {
final String message = exception.getMessage();
if (instance.USE_HTTP_PROXY) {
instance.LAST_ERROR = message;
}
Messages.showErrorDialog(parent, errorText(message));
}
}
});
}
});
}
}
});
} else {
myCheckButton.setVisible(false);
}
}
