/**
* remove highlights (bounded with <marker>...</marker>) from test case file
*
* @param document document to process
*/
private void extractExpectedHighlightsSet(final Document document) {
final String text = document.getText();
final Set<String> markers = myHighlightingTypes.keySet();
final String typesRx = "(?:" + StringUtil.join(markers, ")|(?:") + ")";
final String openingTagRx =
"<("
+ typesRx
+ ")"
+ "(?:\\s+descr=\"((?:[^\"]|\\\\\"|\\\\\\\\\"|\\\\\\[|\\\\\\])*)\")?"
+ "(?:\\s+type=\"([0-9A-Z_]+)\")?"
+ "(?:\\s+foreground=\"([0-9xa-f]+)\")?"
+ "(?:\\s+background=\"([0-9xa-f]+)\")?"
+ "(?:\\s+effectcolor=\"([0-9xa-f]+)\")?"
+ "(?:\\s+effecttype=\"([A-Z]+)\")?"
+ "(?:\\s+fonttype=\"([0-9]+)\")?"
+ "(?:\\s+textAttributesKey=\"((?:[^\"]|\\\\\"|\\\\\\\\\"|\\\\\\[|\\\\\\])*)\")?"
+ "(?:\\s+bundleMsg=\"((?:[^\"]|\\\\\"|\\\\\\\\\")*)\")?"
+ "(/)?>";
final Matcher matcher = Pattern.compile(openingTagRx).matcher(text);
int pos = 0;
final Ref<Integer> textOffset = Ref.create(0);
while (matcher.find(pos)) {
textOffset.set(textOffset.get() + matcher.start() - pos);
pos = extractExpectedHighlight(matcher, text, document, textOffset);
}
}
protected String addToHistoryInner(
final TextRange textRange,
final EditorEx editor,
final boolean erase,
final boolean preserveMarkup) {
final Ref<String> ref = Ref.create("");
final Runnable action =
new Runnable() {
public void run() {
ref.set(addTextRangeToHistory(textRange, editor, preserveMarkup));
if (erase) {
editor
.getDocument()
.deleteString(textRange.getStartOffset(), textRange.getEndOffset());
}
}
};
if (erase) {
ApplicationManager.getApplication().runWriteAction(action);
} else {
ApplicationManager.getApplication().runReadAction(action);
}
// always scroll to end on user input
scrollHistoryToEnd();
queueUiUpdate(true);
return ref.get();
}
public <T> T runWriteAction(@NotNull final Computable<T> computation) {
final Ref<T> ref = Ref.create(null);
runWriteAction(
new Runnable() {
public void run() {
ref.set(computation.compute());
}
});
return ref.get();
}
public static Pair<JPanel, JBList> createActionGroupPanel(
ActionGroup action, final JComponent parent, final Runnable backAction) {
JPanel actionsListPanel = new JPanel(new BorderLayout());
actionsListPanel.setBackground(getProjectsBackground());
final JBList list = new JBList(action.getChildren(null));
list.setBackground(getProjectsBackground());
list.installCellRenderer(
new NotNullFunction<AnAction, JComponent>() {
final JLabel label = new JLabel();
{
label.setBorder(JBUI.Borders.empty(3, 7));
}
@NotNull
@Override
public JComponent fun(AnAction action) {
label.setText(action.getTemplatePresentation().getText());
Icon icon = action.getTemplatePresentation().getIcon();
label.setIcon(icon);
return label;
}
});
JScrollPane pane = ScrollPaneFactory.createScrollPane(list, true);
pane.setBackground(getProjectsBackground());
actionsListPanel.add(pane, BorderLayout.CENTER);
if (backAction != null) {
final JLabel back = new JLabel(AllIcons.Actions.Back);
back.setBorder(JBUI.Borders.empty(3, 7, 10, 7));
back.setHorizontalAlignment(SwingConstants.LEFT);
new ClickListener() {
@Override
public boolean onClick(@NotNull MouseEvent event, int clickCount) {
backAction.run();
return true;
}
}.installOn(back);
actionsListPanel.add(back, BorderLayout.SOUTH);
}
final Ref<Component> selected = Ref.create();
final JPanel main = new JPanel(new BorderLayout());
main.add(actionsListPanel, BorderLayout.WEST);
ListSelectionListener selectionListener =
new ListSelectionListener() {
@Override
public void valueChanged(ListSelectionEvent e) {
if (e.getValueIsAdjusting()) {
// Update when a change has been finalized.
// For instance, selecting an element with mouse fires two consecutive
// ListSelectionEvent events.
return;
}
if (!selected.isNull()) {
main.remove(selected.get());
}
Object value = list.getSelectedValue();
if (value instanceof AbstractActionWithPanel) {
JPanel panel = ((AbstractActionWithPanel) value).createPanel();
panel.setBorder(JBUI.Borders.empty(7, 10));
selected.set(panel);
main.add(selected.get());
for (JButton button : UIUtil.findComponentsOfType(main, JButton.class)) {
if (button.getClientProperty(DialogWrapper.DEFAULT_ACTION) == Boolean.TRUE) {
parent.getRootPane().setDefaultButton(button);
break;
}
}
main.revalidate();
main.repaint();
}
}
};
list.addListSelectionListener(selectionListener);
if (backAction != null) {
new AnAction() {
@Override
public void actionPerformed(@NotNull AnActionEvent e) {
backAction.run();
}
}.registerCustomShortcutSet(KeyEvent.VK_ESCAPE, 0, main);
}
return Pair.create(main, list);
}
private static Trinity<PsiElement, TextRange, Value> getSelectedExpression(
final Project project, final Editor editor, final Point point, final ValueHintType type) {
final Ref<PsiElement> selectedExpression = Ref.create(null);
final Ref<TextRange> currentRange = Ref.create(null);
final Ref<Value> preCalculatedValue = Ref.create(null);
PsiDocumentManager.getInstance(project)
.commitAndRunReadAction(
new Runnable() {
public void run() {
// Point -> offset
final int offset = calculateOffset(editor, point);
PsiFile psiFile =
PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument());
if (psiFile == null || !psiFile.isValid()) return;
int selectionStart = editor.getSelectionModel().getSelectionStart();
int selectionEnd = editor.getSelectionModel().getSelectionEnd();
if ((type == ValueHintType.MOUSE_CLICK_HINT
|| type == ValueHintType.MOUSE_ALT_OVER_HINT)
&& (selectionStart <= offset && offset <= selectionEnd)) {
PsiElement ctx =
(selectionStart > 0)
? psiFile.findElementAt(selectionStart - 1)
: psiFile.findElementAt(selectionStart);
try {
String text = editor.getSelectionModel().getSelectedText();
if (text != null && ctx != null) {
selectedExpression.set(
JVMElementFactories.getFactory(ctx.getLanguage(), project)
.createExpressionFromText(text, ctx));
currentRange.set(
new TextRange(
editor.getSelectionModel().getSelectionStart(),
editor.getSelectionModel().getSelectionEnd()));
}
} catch (IncorrectOperationException ignored) {
}
}
if (currentRange.get() == null) {
PsiElement elementAtCursor = psiFile.findElementAt(offset);
if (elementAtCursor == null) {
return;
}
Pair<PsiElement, TextRange> pair =
findExpression(
elementAtCursor,
type == ValueHintType.MOUSE_CLICK_HINT
|| type == ValueHintType.MOUSE_ALT_OVER_HINT);
if (pair == null) {
if (type == ValueHintType.MOUSE_OVER_HINT) {
final DebuggerSession debuggerSession =
DebuggerManagerEx.getInstanceEx(project)
.getContext()
.getDebuggerSession();
if (debuggerSession != null && debuggerSession.isPaused()) {
final Pair<Method, Value> lastExecuted =
debuggerSession.getProcess().getLastExecutedMethod();
if (lastExecuted != null) {
final Method method = lastExecuted.getFirst();
if (method != null) {
final Pair<PsiElement, TextRange> expressionPair =
findExpression(elementAtCursor, true);
if (expressionPair != null
&& expressionPair.getFirst() instanceof PsiMethodCallExpression) {
final PsiMethodCallExpression methodCallExpression =
(PsiMethodCallExpression) expressionPair.getFirst();
final PsiMethod psiMethod = methodCallExpression.resolveMethod();
if (psiMethod != null) {
final JVMName jvmSignature = JVMNameUtil.getJVMSignature(psiMethod);
try {
if (method.name().equals(psiMethod.getName())
&& method
.signature()
.equals(
jvmSignature.getName(debuggerSession.getProcess()))) {
pair = expressionPair;
preCalculatedValue.set(lastExecuted.getSecond());
}
} catch (EvaluateException ignored) {
}
}
}
}
}
}
}
}
if (pair == null) {
return;
}
selectedExpression.set(pair.getFirst());
currentRange.set(pair.getSecond());
}
}
});
return Trinity.create(selectedExpression.get(), currentRange.get(), preCalculatedValue.get());
}
