/** Patches attributes to be visible under debugger active line */
@SuppressWarnings("UseJBColor")
private static TextAttributes patchAttributesColor(
TextAttributes attributes, TextRange range, Editor editor) {
int line = editor.offsetToLogicalPosition(range.getStartOffset()).line;
for (RangeHighlighter highlighter : editor.getMarkupModel().getAllHighlighters()) {
if (!highlighter.isValid()) continue;
if (highlighter.getTargetArea() == HighlighterTargetArea.LINES_IN_RANGE
&& editor.offsetToLogicalPosition(highlighter.getStartOffset()).line == line) {
TextAttributes textAttributes = highlighter.getTextAttributes();
if (textAttributes != null) {
Color color = textAttributes.getBackgroundColor();
if (color != null
&& color.getBlue() > 128
&& color.getRed() < 128
&& color.getGreen() < 128) {
TextAttributes clone = attributes.clone();
clone.setForegroundColor(Color.orange);
clone.setEffectColor(Color.orange);
return clone;
}
}
}
}
return attributes;
}
public static void showInfoTooltip(
@NotNull final HighlightInfo info,
final Editor editor,
final int defaultOffset,
final int currentWidth) {
if (info.toolTip == null || info.getSeverity() == HighlightSeverity.INFORMATION) return;
Rectangle visibleArea = editor.getScrollingModel().getVisibleArea();
int endOffset = info.highlighter.getEndOffset();
int startOffset = info.highlighter.getStartOffset();
Point top = editor.logicalPositionToXY(editor.offsetToLogicalPosition(startOffset));
Point bottom = editor.logicalPositionToXY(editor.offsetToLogicalPosition(endOffset));
Point bestPoint = new Point(top.x, bottom.y + editor.getLineHeight());
if (!visibleArea.contains(bestPoint)) {
bestPoint = editor.logicalPositionToXY(editor.offsetToLogicalPosition(defaultOffset));
}
Point p =
SwingUtilities.convertPoint(
editor.getContentComponent(),
bestPoint,
editor.getComponent().getRootPane().getLayeredPane());
TooltipController.getInstance()
.showTooltip(editor, p, info.toolTip, currentWidth, false, DAEMON_INFO_GROUP);
}
private static LineRange expandLineRangeToCoverPsiElements(
final LineRange range, Editor editor, final PsiFile file) {
Pair<PsiElement, PsiElement> psiRange = getElementRange(editor, file, range);
if (psiRange == null) return null;
final PsiElement parent =
PsiTreeUtil.findCommonParent(psiRange.getFirst(), psiRange.getSecond());
Pair<PsiElement, PsiElement> elementRange =
getElementRange(parent, psiRange.getFirst(), psiRange.getSecond());
if (elementRange == null) return null;
int endOffset = elementRange.getSecond().getTextRange().getEndOffset();
Document document = editor.getDocument();
if (endOffset > document.getTextLength()) {
LOG.assertTrue(!PsiDocumentManager.getInstance(file.getProject()).isUncommited(document));
LOG.assertTrue(PsiDocumentManagerImpl.checkConsistency(file, document));
}
int endLine;
if (endOffset == document.getTextLength()) {
endLine = document.getLineCount();
} else {
endLine = editor.offsetToLogicalPosition(endOffset).line + 1;
endLine = Math.min(endLine, document.getLineCount());
}
int startLine =
Math.min(
range.startLine,
editor.offsetToLogicalPosition(elementRange.getFirst().getTextOffset()).line);
endLine = Math.max(endLine, range.endLine);
return new LineRange(startLine, endLine);
}
public void commentRange(
int startOffset,
int endOffset,
String commentPrefix,
String commentSuffix,
Commenter commenter) {
final CharSequence chars = myDocument.getCharsSequence();
LogicalPosition caretPosition = myCaret.getLogicalPosition();
if (startOffset == 0 || chars.charAt(startOffset - 1) == '\n') {
if (endOffset == myDocument.getTextLength()
|| endOffset > 0 && chars.charAt(endOffset - 1) == '\n') {
CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(myProject);
CommonCodeStyleSettings settings =
CodeStyleSettingsManager.getSettings(myProject).getCommonSettings(myFile.getLanguage());
String space;
if (!settings.BLOCK_COMMENT_AT_FIRST_COLUMN) {
final FileType fileType = myFile.getFileType();
int line1 = myEditor.offsetToLogicalPosition(startOffset).line;
int line2 = myEditor.offsetToLogicalPosition(endOffset - 1).line;
Indent minIndent =
CommentUtil.getMinLineIndent(myProject, myDocument, line1, line2, fileType);
if (minIndent == null) {
minIndent = codeStyleManager.zeroIndent();
}
space = codeStyleManager.fillIndent(minIndent, fileType);
} else {
space = "";
}
final StringBuilder nestingPrefix = new StringBuilder(space).append(commentPrefix);
if (!commentPrefix.endsWith("\n")) {
nestingPrefix.append("\n");
}
final StringBuilder nestingSuffix = new StringBuilder(space);
nestingSuffix.append(
commentSuffix.startsWith("\n") ? commentSuffix.substring(1) : commentSuffix);
nestingSuffix.append("\n");
TextRange range =
insertNestedComments(
startOffset,
endOffset,
nestingPrefix.toString(),
nestingSuffix.toString(),
commenter);
myCaret.setSelection(range.getStartOffset(), range.getEndOffset());
LogicalPosition pos = new LogicalPosition(caretPosition.line + 1, caretPosition.column);
myCaret.moveToLogicalPosition(pos);
return;
}
}
TextRange range =
insertNestedComments(startOffset, endOffset, commentPrefix, commentSuffix, commenter);
myCaret.setSelection(range.getStartOffset(), range.getEndOffset());
LogicalPosition pos =
new LogicalPosition(caretPosition.line, caretPosition.column + commentPrefix.length());
myCaret.moveToLogicalPosition(pos);
}
@Override
protected LineRange getElementSourceLineRange(
@NotNull PsiElement element, @NotNull Editor editor, @NotNull LineRange oldRange) {
TextRange textRange = element.getTextRange();
if (editor.getDocument().getTextLength() < textRange.getEndOffset()) return null;
int startLine = editor.offsetToLogicalPosition(textRange.getStartOffset()).line;
int endLine = editor.offsetToLogicalPosition(textRange.getEndOffset()).line + 1;
return new LineRange(startLine, endLine);
}
private static void restoreBlockSelection(
Editor editor, List<RangeMarker> caretsAfter, int caretLine) {
int column = -1;
int minLine = Integer.MAX_VALUE;
int maxLine = -1;
for (RangeMarker marker : caretsAfter) {
if (marker.isValid()) {
LogicalPosition lp = editor.offsetToLogicalPosition(marker.getStartOffset());
if (column == -1) {
column = lp.column;
} else if (column != lp.column) {
return;
}
minLine = Math.min(minLine, lp.line);
maxLine = Math.max(maxLine, lp.line);
if (lp.line == caretLine) {
editor.getCaretModel().moveToLogicalPosition(lp);
}
}
}
editor
.getSelectionModel()
.setBlockSelection(
new LogicalPosition(minLine, column), new LogicalPosition(maxLine, column));
}
public void testColumnModeBlockSelectionWithGaps() {
String text =
"public class TestClass {\n"
+ "\n"
+ " int field;\n"
+ "\n"
+ " int otherField;\n"
+ "}";
init(text);
int blockSelectionStartOffset = text.indexOf("int");
Editor editor = myFixture.getEditor();
((EditorEx) editor).setColumnMode(true);
LogicalPosition blockSelectionStartPosition =
editor.offsetToLogicalPosition(blockSelectionStartOffset);
LogicalPosition blockSelectionEndPosition =
new LogicalPosition(
blockSelectionStartPosition.line + 2, blockSelectionStartPosition.column + 16);
editor
.getSelectionModel()
.setBlockSelection(blockSelectionStartPosition, blockSelectionEndPosition);
verifySyntaxInfo(
"foreground=java.awt.Color[r=0,g=0,b=128],fontStyle=1,text=int \n"
+ "foreground=java.awt.Color[r=102,g=14,b=122],text=field\n"
+ "foreground=java.awt.Color[r=0,g=0,b=0],fontStyle=0,text=;\n"
+ "text=\n"
+ "\n"
+ "text=\n"
+ "\n"
+ "foreground=java.awt.Color[r=0,g=0,b=128],fontStyle=1,text=int \n"
+ "foreground=java.awt.Color[r=102,g=14,b=122],text=otherField\n"
+ "foreground=java.awt.Color[r=0,g=0,b=0],fontStyle=0,text=;\n");
}
private void updateCursorHighlighting(boolean scroll) {
hideBalloon();
if (myCursorHighlighter != null) {
HighlightManager.getInstance(mySearchResults.getProject())
.removeSegmentHighlighter(mySearchResults.getEditor(), myCursorHighlighter);
myCursorHighlighter = null;
}
final FindResult cursor = mySearchResults.getCursor();
Editor editor = mySearchResults.getEditor();
SelectionModel selection = editor.getSelectionModel();
if (cursor != null) {
Set<RangeHighlighter> dummy = new HashSet<RangeHighlighter>();
highlightRange(
cursor, new TextAttributes(null, null, Color.BLACK, EffectType.ROUNDED_BOX, 0), dummy);
if (!dummy.isEmpty()) {
myCursorHighlighter = dummy.iterator().next();
}
if (scroll) {
if (mySearchResults.getFindModel().isGlobal()) {
FoldingModel foldingModel = editor.getFoldingModel();
final FoldRegion[] allRegions = editor.getFoldingModel().getAllFoldRegions();
foldingModel.runBatchFoldingOperation(
new Runnable() {
@Override
public void run() {
for (FoldRegion region : allRegions) {
if (!region.isValid()) continue;
if (cursor.intersects(TextRange.create(region))) {
region.setExpanded(true);
}
}
}
});
selection.setSelection(cursor.getStartOffset(), cursor.getEndOffset());
editor.getCaretModel().moveToOffset(cursor.getEndOffset());
editor.getScrollingModel().scrollToCaret(ScrollType.CENTER);
} else {
if (!SearchResults.insideVisibleArea(editor, cursor)) {
LogicalPosition pos = editor.offsetToLogicalPosition(cursor.getStartOffset());
editor.getScrollingModel().scrollTo(pos, ScrollType.CENTER);
}
}
}
editor
.getScrollingModel()
.runActionOnScrollingFinished(
new Runnable() {
@Override
public void run() {
showReplacementPreview();
}
});
}
}
private static void indentLinesIn(
final Editor editor,
final PsiFile file,
final Document document,
final Project project,
RangeMarker range) {
final CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(project);
int line1 = editor.offsetToLogicalPosition(range.getStartOffset()).line;
int line2 = editor.offsetToLogicalPosition(range.getEndOffset()).line;
while (!lineContainsNonSpaces(document, line1) && line1 < line2) line1++;
while (!lineContainsNonSpaces(document, line2) && line1 < line2) line2--;
final FileViewProvider provider = file.getViewProvider();
PsiFile rootToAdjustIndentIn = provider.getPsi(provider.getBaseLanguage());
codeStyleManager.adjustLineIndent(
rootToAdjustIndentIn,
new TextRange(document.getLineStartOffset(line1), document.getLineStartOffset(line2)));
}
private static boolean isDeclarationVisible(PsiElement container, Editor editor) {
Rectangle viewRect = editor.getScrollingModel().getVisibleArea();
final TextRange range = DeclarationRangeUtil.getPossibleDeclarationAtRange(container);
if (range == null) {
return false;
}
LogicalPosition pos = editor.offsetToLogicalPosition(range.getStartOffset());
Point loc = editor.logicalPositionToXY(pos);
return loc.y >= viewRect.y;
}
private static void highlightInEditor(
final Project project, final IncludeDuplicate pair, final Editor editor) {
final HighlightManager highlightManager = HighlightManager.getInstance(project);
EditorColorsManager colorsManager = EditorColorsManager.getInstance();
TextAttributes attributes =
colorsManager.getGlobalScheme().getAttributes(EditorColors.SEARCH_RESULT_ATTRIBUTES);
final int startOffset = pair.getStart().getTextRange().getStartOffset();
final int endOffset = pair.getEnd().getTextRange().getEndOffset();
highlightManager.addRangeHighlight(editor, startOffset, endOffset, attributes, true, null);
final LogicalPosition logicalPosition = editor.offsetToLogicalPosition(startOffset);
editor.getScrollingModel().scrollTo(logicalPosition, ScrollType.MAKE_VISIBLE);
}
public void testBlockSelection() {
String text =
"package org;\n"
+ "\n"
+ "public class TestClass {\n"
+ "\n"
+ " int field;\n"
+ "\n"
+ " public int getField() {\n"
+ " return field;\n"
+ " }\n"
+ "}";
init(text);
int blockSelectionStartOffset = text.indexOf("public int");
Editor editor = myFixture.getEditor();
LogicalPosition blockSelectionStartPosition =
editor.offsetToLogicalPosition(blockSelectionStartOffset);
LogicalPosition blockSelectionEndPosition =
new LogicalPosition(
blockSelectionStartPosition.line + 2,
editor.offsetToLogicalPosition(text.indexOf('{', blockSelectionStartOffset)).column
+ 1);
editor
.getSelectionModel()
.setBlockSelection(blockSelectionStartPosition, blockSelectionEndPosition);
verifySyntaxInfo(
"foreground=java.awt.Color[r=0,g=0,b=128],fontStyle=1,text=public int \n"
+ "foreground=java.awt.Color[r=0,g=0,b=0],fontStyle=0,text=getField() {\n"
+ "text=\n"
+ "\n"
+ "text= \n"
+ "foreground=java.awt.Color[r=0,g=0,b=128],fontStyle=1,text=return \n"
+ "foreground=java.awt.Color[r=102,g=14,b=122],text=field\n"
+ "foreground=java.awt.Color[r=0,g=0,b=0],fontStyle=0,text=;\n"
+ "text=\n"
+ "\n"
+ "text=}\n");
}
/**
* Applies given caret/selection state to the editor. Editor text must have been set up
* previously.
*/
public static void setCaretsAndSelection(Editor editor, CaretAndSelectionState caretsState) {
CaretModel caretModel = editor.getCaretModel();
if (caretModel.supportsMultipleCarets()) {
List<CaretState> states = new ArrayList<CaretState>(caretsState.carets.size());
for (CaretInfo caret : caretsState.carets) {
states.add(
new CaretState(
caret.position == null
? null
: editor.offsetToLogicalPosition(caret.getCaretOffset(editor.getDocument())),
caret.selection == null
? null
: editor.offsetToLogicalPosition(caret.selection.getStartOffset()),
caret.selection == null
? null
: editor.offsetToLogicalPosition(caret.selection.getEndOffset())));
}
caretModel.setCaretsAndSelections(states);
} else {
assertEquals("Multiple carets are not supported by the model", 1, caretsState.carets.size());
CaretInfo caret = caretsState.carets.get(0);
if (caret.position != null) {
caretModel.moveToOffset(caret.getCaretOffset(editor.getDocument()));
}
if (caret.selection != null) {
editor
.getSelectionModel()
.setSelection(caret.selection.getStartOffset(), caret.selection.getEndOffset());
} else {
editor.getSelectionModel().removeSelection();
}
}
if (caretsState.blockSelection != null) {
editor
.getSelectionModel()
.setBlockSelection(
editor.offsetToLogicalPosition(caretsState.blockSelection.getStartOffset()),
editor.offsetToLogicalPosition(caretsState.blockSelection.getEndOffset()));
}
}
private static void indentLinesIn(
final Editor editor,
final PsiFile file,
final Document document,
final Project project,
RangeMarker range) {
final CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(project);
int line1 = editor.offsetToLogicalPosition(range.getStartOffset()).line;
int line2 = editor.offsetToLogicalPosition(range.getEndOffset()).line;
/* if (PsiUtil.isInJspFile(file)) {
// This version is slow because of each moved line cause commit
// and right now we unable to fix JSP formatter quickly
// TODO: remove this code
for (int line = line1; line <= line2; line++) {
if (lineContainsNonSpaces(document, line)) {
int lineStart = document.getLineStartOffset(line);
codeStyleManager.adjustLineIndent(document, lineStart);
}
}
}
else {*/
while (!lineContainsNonSpaces(document, line1) && line1 <= line2) line1++;
while (!lineContainsNonSpaces(document, line2) && line2 > line1) line2--;
try {
final FileViewProvider provider = file.getViewProvider();
PsiFile rootToAdjustIndentIn = provider.getPsi(provider.getBaseLanguage());
codeStyleManager.adjustLineIndent(
rootToAdjustIndentIn,
new TextRange(document.getLineStartOffset(line1), document.getLineStartOffset(line2)));
} catch (IncorrectOperationException ex) {
throw new RuntimeException(ex);
}
/* } */
}
@Override
public void paint(Graphics gfx) {
Graphics2D g = (Graphics2D) gfx;
g.setColor(editor.getColorsScheme().getDefaultBackground());
g.fillRect(0, 0, getWidth(), getHeight());
logger.debug(String.format("Rendering to buffer: %d", activeBuffer));
if (activeBuffer >= 0) {
paintSelection(g);
Minimap minimap = minimaps[activeBuffer];
Rectangle visibleArea = editor.getScrollingModel().getVisibleArea();
double documentEndY =
editor
.logicalPositionToXY(
editor.offsetToLogicalPosition(editor.getDocument().getTextLength() - 1))
.getY();
coords
.setMinimap(minimap)
.setPanelHeight(getHeight())
.setPanelWidth(getWidth())
.setPercentageComplete(
visibleArea.getMinY()
/ (documentEndY - (visibleArea.getMaxY() - visibleArea.getMinY())))
.setHidpiScale(getHidpiScale());
Rectangle src = coords.getImageSource();
Rectangle dest = coords.getImageDestination();
// Draw the image and scale it to stretch vertically.
g.drawImage(
minimap.img, // source image
dest.x,
dest.y,
dest.width,
dest.height,
src.x,
src.y,
src.width,
src.height,
null);
paintVisibleWindow(g);
}
}
public boolean checkAvailable(
@NotNull final Editor editor,
@NotNull final PsiFile file,
@NotNull final MoveInfo info,
final boolean down) {
LineRange range = StatementUpDownMover.getLineRangeFromSelection(editor);
final int maxLine = editor.offsetToLogicalPosition(editor.getDocument().getTextLength()).line;
if (range.startLine == 0 && !down) return false;
if (range.endLine >= maxLine && down) return false;
int nearLine = down ? range.endLine : range.startLine - 1;
info.toMove = range;
info.toMove2 = new LineRange(nearLine, nearLine + 1);
return true;
}
@Override
public boolean isEnabled(Editor editor, DataContext dataContext) {
if (editor.isViewer() || editor.isOneLineMode()) return false;
final Project project = editor.getProject();
if (project == null || project.isDisposed()) return false;
final PsiDocumentManager documentManager = PsiDocumentManager.getInstance(project);
final Document document = editor.getDocument();
documentManager.commitDocument(document);
PsiFile psiFile = documentManager.getPsiFile(document);
PsiFile file = getRoot(psiFile, editor);
if (file == null) return false;
final MoverWrapper mover = getSuitableMover(editor, file);
if (mover == null || mover.getInfo().toMove2 == null) return false;
final int maxLine = editor.offsetToLogicalPosition(editor.getDocument().getTextLength()).line;
final LineRange range = mover.getInfo().toMove;
if (range.startLine == 0 && !isDown) return false;
return range.endLine <= maxLine || !isDown;
}
public void documentChanged(@NotNull DocumentEvent event) {
if (!VimPlugin.isEnabled()) {
return;
}
Project[] projs = ProjectManager.getInstance().getOpenProjects();
for (Project proj : projs) {
Editor[] editors = EditorFactory.getInstance().getEditors(event.getDocument(), proj);
for (Editor editor : editors) {
Collection hls = EditorData.getLastHighlights(editor);
if (hls == null) {
continue;
}
int soff = event.getOffset();
int eoff = soff + event.getNewLength();
if (logger.isDebugEnabled()) {
logger.debug("hls=" + hls);
logger.debug("event=" + event);
}
Iterator iter = hls.iterator();
while (iter.hasNext()) {
RangeHighlighter rh = (RangeHighlighter) iter.next();
if (!rh.isValid() || (eoff >= rh.getStartOffset() && soff <= rh.getEndOffset())) {
iter.remove();
editor.getMarkupModel().removeHighlighter(rh);
}
}
int sl = editor.offsetToLogicalPosition(soff).line;
int el = editor.offsetToLogicalPosition(eoff).line;
VimPlugin.getSearch().highlightSearchLines(editor, false, sl, el);
hls = EditorData.getLastHighlights(editor);
if (logger.isDebugEnabled()) {
logger.debug("sl=" + sl + ", el=" + el);
logger.debug("hls=" + hls);
}
}
}
}
@Override
@NotNull
public Pair<Point, Short> getBestPointPosition(
LightweightHint hint,
final PsiElement list,
int offset,
final boolean awtTooltip,
short preferredPosition) {
if (list != null) {
TextRange range = list.getTextRange();
if (!range.contains(offset)) {
offset = range.getStartOffset() + 1;
}
}
if (previousOffset == offset) return Pair.create(previousBestPoint, previousBestPosition);
final boolean isMultiline =
list != null && StringUtil.containsAnyChar(list.getText(), "\n\r");
final LogicalPosition pos = myEditor.offsetToLogicalPosition(offset);
Pair<Point, Short> position;
if (!isMultiline) {
position =
chooseBestHintPosition(
myEditor.getProject(),
myEditor,
pos.line,
pos.column,
hint,
awtTooltip,
preferredPosition);
} else {
Point p = HintManagerImpl.getHintPosition(hint, myEditor, pos, HintManager.ABOVE);
position = new Pair<Point, Short>(p, HintManager.ABOVE);
}
previousBestPoint = position.getFirst();
previousBestPosition = position.getSecond();
previousOffset = offset;
return position;
}
private void highlightUsages() {
Editor e = getEditor();
if (e == null) return;
boolean foundVisibleElement = false;
int offset = Integer.MAX_VALUE;
for (SearchResult sr : searchResults.values()) {
Map<Node, PsiElement> match = sr.getMatch();
TextAttributes textAttributes = createUniqueTextAttrsFor(sr);
PsiElement targetElement = match.get(pattern.getTheOne());
if (!foundVisibleElement && insideVisibleArea(e, targetElement)) {
foundVisibleElement = true;
}
if (!foundVisibleElement && targetElement.getTextOffset() < offset) {
offset = targetElement.getTextOffset();
}
for (PsiElement element : match.values()) {
TextAttributes attributes = textAttributes;
if (element == targetElement) {
attributes = MAIN_TARGET_ATTRIBUTES;
}
if (element instanceof XmlTag) {
element = element.getFirstChild().getNextSibling();
}
TextRange textRange = element.getTextRange();
e.getMarkupModel()
.addRangeHighlighter(
textRange.getStartOffset(),
textRange.getEndOffset(),
HighlighterLayer.SELECTION + 1,
attributes,
HighlighterTargetArea.EXACT_RANGE);
}
}
if (!foundVisibleElement && offset != Integer.MAX_VALUE) {
e.getScrollingModel().scrollTo(e.offsetToLogicalPosition(offset), ScrollType.CENTER);
}
}
public boolean searchAndReplace(
@NotNull Editor editor, @NotNull LineRange range, @NotNull String excmd, String exarg) {
boolean res = true;
// Explicitly exit visual mode here, so that visual mode marks don't change when we move the
// cursor to a match.
if (CommandState.getInstance(editor).getMode() == CommandState.Mode.VISUAL) {
VimPlugin.getMotion().exitVisual(editor);
}
CharPointer cmd = new CharPointer(new StringBuffer(exarg));
// sub_nsubs = 0;
// sub_nlines = 0;
int which_pat;
if (excmd.equals("~")) {
which_pat = RE_LAST; /* use last used regexp */
} else {
which_pat = RE_SUBST; /* use last substitute regexp */
}
CharPointer pat;
CharPointer sub;
char delimiter;
/* new pattern and substitution */
if (excmd.charAt(0) == 's'
&& !cmd.isNul()
&& !Character.isWhitespace(cmd.charAt())
&& "0123456789cegriIp|\"".indexOf(cmd.charAt()) == -1) {
/* don't accept alphanumeric for separator */
if (CharacterClasses.isAlpha(cmd.charAt())) {
VimPlugin.showMessage(MessageHelper.message(Msg.E146));
return false;
}
/*
* undocumented vi feature:
* "\/sub/" and "\?sub?" use last used search pattern (almost like
* //sub/r). "\&sub&" use last substitute pattern (like //sub/).
*/
if (cmd.charAt() == '\\') {
cmd.inc();
if ("/?&".indexOf(cmd.charAt()) == -1) {
VimPlugin.showMessage(MessageHelper.message(Msg.e_backslash));
return false;
}
if (cmd.charAt() != '&') {
which_pat = RE_SEARCH; /* use last '/' pattern */
}
pat = new CharPointer(""); /* empty search pattern */
delimiter = cmd.charAt(); /* remember delimiter character */
cmd.inc();
} else /* find the end of the regexp */ {
which_pat = RE_LAST; /* use last used regexp */
delimiter = cmd.charAt(); /* remember delimiter character */
cmd.inc();
pat = cmd.ref(0); /* remember start of search pat */
cmd = RegExp.skip_regexp(cmd, delimiter, true);
if (cmd.charAt() == delimiter) /* end delimiter found */ {
cmd.set('\u0000').inc(); /* replace it with a NUL */
}
}
/*
* Small incompatibility: vi sees '\n' as end of the command, but in
* Vim we want to use '\n' to find/substitute a NUL.
*/
sub = cmd.ref(0); /* remember the start of the substitution */
while (!cmd.isNul()) {
if (cmd.charAt() == delimiter) /* end delimiter found */ {
cmd.set('\u0000').inc(); /* replace it with a NUL */
break;
}
if (cmd.charAt(0) == '\\' && cmd.charAt(1) != 0) /* skip escaped characters */ {
cmd.inc();
}
cmd.inc();
}
} else /* use previous pattern and substitution */ {
if (lastReplace == null) /* there is no previous command */ {
VimPlugin.showMessage(MessageHelper.message(Msg.e_nopresub));
return false;
}
pat = null; /* search_regcomp() will use previous pattern */
sub = new CharPointer(lastReplace);
}
/*
* Find trailing options. When '&' is used, keep old options.
*/
if (cmd.charAt() == '&') {
cmd.inc();
} else {
do_all = Options.getInstance().isSet("gdefault");
do_ask = false;
do_error = true;
// do_print = false;
do_ic = 0;
}
while (!cmd.isNul()) {
/*
* Note that 'g' and 'c' are always inverted, also when p_ed is off.
* 'r' is never inverted.
*/
if (cmd.charAt() == 'g') {
do_all = !do_all;
} else if (cmd.charAt() == 'c') {
do_ask = !do_ask;
} else if (cmd.charAt() == 'e') {
do_error = !do_error;
} else if (cmd.charAt() == 'r') /* use last used regexp */ {
which_pat = RE_LAST;
} else if (cmd.charAt() == 'i') /* ignore case */ {
do_ic = 'i';
} else if (cmd.charAt() == 'I') /* don't ignore case */ {
do_ic = 'I';
} else if (cmd.charAt() != 'p') {
break;
}
cmd.inc();
}
int line1 = range.getStartLine();
int line2 = range.getEndLine();
/*
* check for a trailing count
*/
cmd = CharHelper.skipwhite(cmd);
if (CharacterClasses.isDigit(cmd.charAt())) {
int i = CharHelper.getdigits(cmd);
if (i <= 0 && do_error) {
VimPlugin.showMessage(MessageHelper.message(Msg.e_zerocount));
return false;
}
line1 = line2;
line2 = EditorHelper.normalizeLine(editor, line1 + i - 1);
}
/*
* check for trailing command or garbage
*/
cmd = CharHelper.skipwhite(cmd);
if (!cmd.isNul() && cmd.charAt() != '"') /* if not end-of-line or comment */ {
VimPlugin.showMessage(MessageHelper.message(Msg.e_trailing));
return false;
}
String pattern = "";
if (pat == null || pat.isNul()) {
switch (which_pat) {
case RE_LAST:
pattern = lastPattern;
break;
case RE_SEARCH:
pattern = lastSearch;
break;
case RE_SUBST:
pattern = lastSubstitute;
break;
}
} else {
pattern = pat.toString();
}
lastSubstitute = pattern;
if (pattern != null) {
setLastPattern(editor, pattern);
}
// int start = editor.logicalPositionToOffset(new LogicalPosition(line1, 0));
// int end = editor.logicalPositionToOffset(new LogicalPosition(line2,
// EditorHelper.getLineLength(editor, line2)));
int start = editor.getDocument().getLineStartOffset(line1);
int end = editor.getDocument().getLineEndOffset(line2);
RegExp sp;
RegExp.regmmatch_T regmatch = new RegExp.regmmatch_T();
sp = new RegExp();
regmatch.regprog = sp.vim_regcomp(pattern, 1);
if (regmatch.regprog == null) {
if (do_error) {
VimPlugin.showMessage(MessageHelper.message(Msg.e_invcmd));
}
return false;
}
/* the 'i' or 'I' flag overrules 'ignorecase' and 'smartcase' */
if (do_ic == 'i') {
regmatch.rmm_ic = true;
} else if (do_ic == 'I') {
regmatch.rmm_ic = false;
}
/*
* ~ in the substitute pattern is replaced with the old pattern.
* We do it here once to avoid it to be replaced over and over again.
* But don't do it when it starts with "\=", then it's an expression.
*/
if (!(sub.charAt(0) == '\\' && sub.charAt(1) == '=') && lastReplace != null) {
StringBuffer tmp = new StringBuffer(sub.toString());
int pos = 0;
while ((pos = tmp.indexOf("~", pos)) != -1) {
if (pos == 0 || tmp.charAt(pos - 1) != '\\') {
tmp.replace(pos, pos + 1, lastReplace);
pos += lastReplace.length();
}
pos++;
}
sub = new CharPointer(tmp);
}
lastReplace = sub.toString();
searchHighlight(false);
if (logger.isDebugEnabled()) {
logger.debug("search range=[" + start + "," + end + "]");
logger.debug("pattern=" + pattern + ", replace=" + sub);
}
int lastMatch = -1;
int lastLine = -1;
int searchcol = 0;
boolean firstMatch = true;
boolean got_quit = false;
int lcount = EditorHelper.getLineCount(editor);
for (int lnum = line1; lnum <= line2 && !got_quit; ) {
CharacterPosition newpos = null;
int nmatch = sp.vim_regexec_multi(regmatch, editor, lcount, lnum, searchcol);
if (nmatch > 0) {
if (firstMatch) {
VimPlugin.getMark().saveJumpLocation(editor);
firstMatch = false;
}
String match = sp.vim_regsub_multi(regmatch, lnum, sub, 1, false);
// logger.debug("found match[" + spos + "," + epos + "] - replace " + match);
int line = lnum + regmatch.startpos[0].lnum;
CharacterPosition startpos =
new CharacterPosition(lnum + regmatch.startpos[0].lnum, regmatch.startpos[0].col);
CharacterPosition endpos =
new CharacterPosition(lnum + regmatch.endpos[0].lnum, regmatch.endpos[0].col);
int startoff = EditorHelper.characterPositionToOffset(editor, startpos);
int endoff = EditorHelper.characterPositionToOffset(editor, endpos);
int newend = startoff + match.length();
if (do_all || line != lastLine) {
boolean doReplace = true;
if (do_ask) {
// editor.getSelectionModel().setSelection(startoff, endoff);
RangeHighlighter hl = highlightConfirm(editor, startoff, endoff);
int choice = getConfirmChoice(match);
// editor.getSelectionModel().removeSelection();
editor.getMarkupModel().removeHighlighter(hl);
switch (choice) {
case 0: // Yes
doReplace = true;
break;
case 1: // No
doReplace = false;
break;
case 2: // All
do_ask = false;
break;
case JOptionPane.CLOSED_OPTION:
case 3: // Quit
doReplace = false;
got_quit = true;
break;
case 4: // Last
do_all = false;
line2 = lnum;
doReplace = true;
break;
}
}
if (doReplace) {
editor.getDocument().replaceString(startoff, endoff, match);
lastMatch = startoff;
newpos = EditorHelper.offsetToCharacterPosition(editor, newend);
lnum += newpos.line - endpos.line;
line2 += newpos.line - endpos.line;
}
}
lastLine = line;
lnum += nmatch - 1;
if (do_all && startoff != endoff) {
if (newpos != null) {
lnum = newpos.line;
searchcol = newpos.column;
} else {
searchcol = endpos.column;
}
} else {
searchcol = 0;
lnum++;
}
} else {
lnum++;
searchcol = 0;
}
}
if (lastMatch != -1) {
MotionGroup.moveCaret(
editor,
VimPlugin.getMotion()
.moveCaretToLineStartSkipLeading(
editor, editor.offsetToLogicalPosition(lastMatch).line));
} else {
VimPlugin.showMessage(MessageHelper.message(Msg.e_patnotf2, pattern));
}
return res;
}
private int findItOffset(
@NotNull Editor editor, int startOffset, int count, int dir, boolean noSmartCase) {
boolean wrap = Options.getInstance().isSet("wrapscan");
TextRange range = findIt(editor, startOffset, count, dir, noSmartCase, wrap, true, true);
if (range == null) {
return -1;
}
// highlightMatch(editor, range.getStartOffset(), range.getEndOffset());
ParsePosition pp = new ParsePosition(0);
int res = range.getStartOffset();
if (lastOffset == null) {
return -1;
}
if (lastOffset.length() == 0) {
return range.getStartOffset();
} else if (Character.isDigit(lastOffset.charAt(0))
|| lastOffset.charAt(0) == '+'
|| lastOffset.charAt(0) == '-') {
int lineOffset = 0;
if (lastOffset.equals("+")) {
lineOffset = 1;
} else if (lastOffset.equals("-")) {
lineOffset = -1;
} else {
if (lastOffset.charAt(0) == '+') {
lastOffset = lastOffset.substring(1);
}
NumberFormat nf = NumberFormat.getIntegerInstance();
pp = new ParsePosition(0);
Number num = nf.parse(lastOffset, pp);
if (num != null) {
lineOffset = num.intValue();
}
}
int line = editor.offsetToLogicalPosition(range.getStartOffset()).line;
int newLine = EditorHelper.normalizeLine(editor, line + lineOffset);
res = VimPlugin.getMotion().moveCaretToLineStart(editor, newLine);
} else if ("ebs".indexOf(lastOffset.charAt(0)) != -1) {
int charOffset = 0;
if (lastOffset.length() >= 2) {
if ("+-".indexOf(lastOffset.charAt(1)) != -1) {
charOffset = 1;
}
NumberFormat nf = NumberFormat.getIntegerInstance();
pp = new ParsePosition(lastOffset.charAt(1) == '+' ? 2 : 1);
Number num = nf.parse(lastOffset, pp);
if (num != null) {
charOffset = num.intValue();
}
}
int base = range.getStartOffset();
if (lastOffset.charAt(0) == 'e') {
base = range.getEndOffset() - 1;
}
res = Math.max(0, Math.min(base + charOffset, EditorHelper.getFileSize(editor) - 1));
}
int ppos = pp.getIndex();
if (ppos < lastOffset.length() - 1 && lastOffset.charAt(ppos) == ';') {
int flags;
if (lastOffset.charAt(ppos + 1) == '/') {
flags = Command.FLAG_SEARCH_FWD;
} else if (lastOffset.charAt(ppos + 1) == '?') {
flags = Command.FLAG_SEARCH_REV;
} else {
return res;
}
if (lastOffset.length() - ppos > 2) {
ppos++;
}
res = search(editor, lastOffset.substring(ppos + 1), res, 1, flags);
return res;
} else {
return res;
}
}
private static void doPaste(
final Editor editor,
final Project project,
final PsiFile file,
final Document document,
final Producer<Transferable> producer) {
Transferable content = null;
if (producer != null) {
content = producer.produce();
} else {
CopyPasteManager manager = CopyPasteManager.getInstance();
if (manager.areDataFlavorsAvailable(DataFlavor.stringFlavor)) {
content = manager.getContents();
if (content != null) {
manager.stopKillRings();
}
}
}
if (content != null) {
String text = null;
try {
text = (String) content.getTransferData(DataFlavor.stringFlavor);
} catch (Exception e) {
editor.getComponent().getToolkit().beep();
}
if (text == null) return;
final CodeInsightSettings settings = CodeInsightSettings.getInstance();
final Map<CopyPastePostProcessor, TextBlockTransferableData> extraData =
new HashMap<CopyPastePostProcessor, TextBlockTransferableData>();
for (CopyPastePostProcessor processor :
Extensions.getExtensions(CopyPastePostProcessor.EP_NAME)) {
TextBlockTransferableData data = processor.extractTransferableData(content);
if (data != null) {
extraData.put(processor, data);
}
}
text = TextBlockTransferable.convertLineSeparators(text, "\n", extraData.values());
final CaretModel caretModel = editor.getCaretModel();
final SelectionModel selectionModel = editor.getSelectionModel();
final int col = caretModel.getLogicalPosition().column;
// There is a possible case that we want to perform paste while there is an active selection
// at the editor and caret is located
// inside it (e.g. Ctrl+A is pressed while caret is not at the zero column). We want to insert
// the text at selection start column
// then, hence, inserted block of text should be indented according to the selection start as
// well.
final int blockIndentAnchorColumn;
final int caretOffset = caretModel.getOffset();
if (selectionModel.hasSelection() && caretOffset >= selectionModel.getSelectionStart()) {
blockIndentAnchorColumn =
editor.offsetToLogicalPosition(selectionModel.getSelectionStart()).column;
} else {
blockIndentAnchorColumn = col;
}
// We assume that EditorModificationUtil.insertStringAtCaret() is smart enough to remove
// currently selected text (if any).
RawText rawText = RawText.fromTransferable(content);
String newText = text;
for (CopyPastePreProcessor preProcessor :
Extensions.getExtensions(CopyPastePreProcessor.EP_NAME)) {
newText = preProcessor.preprocessOnPaste(project, file, editor, newText, rawText);
}
int indentOptions =
text.equals(newText) ? settings.REFORMAT_ON_PASTE : CodeInsightSettings.REFORMAT_BLOCK;
text = newText;
if (LanguageFormatting.INSTANCE.forContext(file) == null
&& indentOptions != CodeInsightSettings.NO_REFORMAT) {
indentOptions = CodeInsightSettings.INDENT_BLOCK;
}
final String _text = text;
ApplicationManager.getApplication()
.runWriteAction(
new Runnable() {
@Override
public void run() {
EditorModificationUtil.insertStringAtCaret(editor, _text, false, true);
}
});
int length = text.length();
int offset = caretModel.getOffset() - length;
if (offset < 0) {
length += offset;
offset = 0;
}
final RangeMarker bounds = document.createRangeMarker(offset, offset + length);
caretModel.moveToOffset(bounds.getEndOffset());
editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
selectionModel.removeSelection();
final Ref<Boolean> indented = new Ref<Boolean>(Boolean.FALSE);
for (Map.Entry<CopyPastePostProcessor, TextBlockTransferableData> e : extraData.entrySet()) {
//noinspection unchecked
e.getKey()
.processTransferableData(project, editor, bounds, caretOffset, indented, e.getValue());
}
boolean pastedTextContainsWhiteSpacesOnly =
CharArrayUtil.shiftForward(document.getCharsSequence(), bounds.getStartOffset(), " \n\t")
>= bounds.getEndOffset();
VirtualFile virtualFile = file.getVirtualFile();
if (!pastedTextContainsWhiteSpacesOnly
&& (virtualFile == null
|| !SingleRootFileViewProvider.isTooLargeForIntelligence(virtualFile))) {
final int indentOptions1 = indentOptions;
ApplicationManager.getApplication()
.runWriteAction(
new Runnable() {
@Override
public void run() {
switch (indentOptions1) {
case CodeInsightSettings.INDENT_BLOCK:
if (!indented.get()) {
indentBlock(
project,
editor,
bounds.getStartOffset(),
bounds.getEndOffset(),
blockIndentAnchorColumn);
}
break;
case CodeInsightSettings.INDENT_EACH_LINE:
if (!indented.get()) {
indentEachLine(
project, editor, bounds.getStartOffset(), bounds.getEndOffset());
}
break;
case CodeInsightSettings.REFORMAT_BLOCK:
indentEachLine(
project,
editor,
bounds.getStartOffset(),
bounds
.getEndOffset()); // this is needed for example when inserting a
// comment before method
reformatBlock(
project, editor, bounds.getStartOffset(), bounds.getEndOffset());
break;
}
}
});
}
if (bounds.isValid()) {
caretModel.moveToOffset(bounds.getEndOffset());
editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
selectionModel.removeSelection();
editor.putUserData(EditorEx.LAST_PASTED_REGION, TextRange.create(bounds));
}
}
}
private boolean insideVisibleArea(Editor e, PsiElement targetElement) {
Rectangle visibleArea = e.getScrollingModel().getVisibleArea();
Point point = e.logicalPositionToXY(e.offsetToLogicalPosition(targetElement.getTextOffset()));
return visibleArea.contains(point);
}
private static int findSentenceStart(
Editor editor,
CharSequence chars,
int start,
int max,
int dir,
boolean countCurrent,
boolean multiple) {
// Save off the next paragraph since a paragraph is a valid sentence.
int lline = editor.offsetToLogicalPosition(start).line;
int np = findNextParagraph(editor, lline, dir, false, multiple);
int end;
if (chars.charAt(start) == '\n' && !countCurrent) {
end = findSentenceEnd(editor, chars, start, max, -1, false, multiple);
} else {
end = findSentenceEnd(editor, chars, start, max, -1, true, multiple);
}
if (end == start && countCurrent && chars.charAt(end) == '\n') {
return end;
}
int pos = end - 1;
if (end >= 0) {
int offset = end + 1;
while (offset < max) {
char ch = chars.charAt(offset);
if (!Character.isWhitespace(ch)) {
break;
}
offset++;
}
if (dir > 0) {
if (offset == start && countCurrent) {
return offset;
} else if (offset > start) {
return offset;
}
} else {
if (offset == start && countCurrent) {
return offset;
} else if (offset < start) {
return offset;
}
}
}
if (dir > 0) {
end = findSentenceEnd(editor, chars, start, max, dir, true, multiple);
} else {
end = findSentenceEnd(editor, chars, pos, max, dir, countCurrent, multiple);
}
int res = end + 1;
if (end != -1 && (chars.charAt(end) != '\n' || !countCurrent)) {
while (res < max) {
char ch = chars.charAt(res);
if (!Character.isWhitespace(ch)) {
break;
}
res++;
}
}
// Now let's see which to return, the sentence we found or the paragraph we found.
// This mess returns which ever is closer to our starting point (and in the right direction).
if (res >= 0 && np >= 0) {
if (dir > 0) {
if (np < res || res < start) {
res = np;
}
} else {
if (np > res || (res >= start && !countCurrent)) {
res = np;
}
}
} else if (res == -1 && np >= 0) {
res = np;
}
// else we found neither, res already -1
return res;
}
private static int findSentenceEnd(
Editor editor,
CharSequence chars,
int start,
int max,
int dir,
boolean countCurrent,
boolean multiple) {
if (dir > 0 && start >= EditorHelper.getFileSize(editor) - 1) {
return -1;
} else if (dir < 0 && start <= 0) {
return -1;
}
// Save off the next paragraph since a paragraph is a valid sentence.
int lline = editor.offsetToLogicalPosition(start).line;
int np = findNextParagraph(editor, lline, dir, false, multiple);
// Sections are also end-of-sentence markers. However, { and } in column 1 don't count.
// Since our section implementation only supports these and form-feed chars, we'll just
// check for form-feeds below.
int res = -1;
int offset = start;
boolean found = false;
// Search forward looking for a candidate end-of-sentence character (., !, or ?)
while (offset >= 0 && offset < max && !found) {
char ch = chars.charAt(offset);
if (".!?".indexOf(ch) >= 0) {
int end = offset; // Save where we found the punctuation.
offset++;
// This can be followed by any number of ), ], ", or ' characters.
while (offset < max) {
ch = chars.charAt(offset);
if (")]\"'".indexOf(ch) == -1) {
break;
}
offset++;
}
// The next character must be whitespace for this to be a valid end-of-sentence.
if (offset >= max || Character.isWhitespace(ch)) {
// So we have found the end of the next sentence. Now let's see if we ended
// where we started (or further) on a back search. This will happen if we happen
// to start this whole search already on a sentence end.
if (offset - 1 == start && !countCurrent) {
// Skip back to the sentence end so we can search backward from there
// for the real previous sentence.
offset = end;
} else {
// Yeah - we found the real end-of-sentence. Save it off.
res = offset - 1;
found = true;
}
} else {
// Turned out not to be an end-of-sentence so move back to where we were.
offset = end;
}
} else if (ch == '\n') {
int end = offset; // Save where we found the punctuation.
if (dir > 0) {
offset++;
while (offset < max) {
ch = chars.charAt(offset);
if (ch != '\n') {
offset--;
break;
}
if (offset == np && (end - 1 != start || countCurrent)) {
break;
}
offset++;
}
if (offset == np && (end - 1 != start || countCurrent)) {
res = end - 1;
found = true;
} else if (offset > end) {
res = offset;
np = res;
found = true;
} else if (offset == end) {
if (offset > 0 && chars.charAt(offset - 1) == '\n' && countCurrent) {
res = end;
np = res;
found = true;
}
}
} else {
offset--;
while (offset >= 0) {
ch = chars.charAt(offset);
if (ch != '\n') {
offset++;
break;
}
offset--;
}
if (offset < end) {
if (end == start && countCurrent) {
res = end;
} else {
res = offset - 1;
}
found = true;
}
}
offset = end;
}
// Form-feeds are also end-of-sentence markers.
else if (ch == '\u000C') {
res = offset;
found = true;
}
offset += dir;
}
// Now let's see which to return, the sentence we found or the paragraph we found.
// This mess returns which ever is closer to our starting point (and in the right direction).
if (res >= 0 && np >= 0) {
if (dir > 0) {
if (np < res || res < start) {
res = np;
}
} else {
if (np > res || (res >= start && !countCurrent)) {
res = np;
}
}
}
/*
else if (res == -1 && np >= 0)
{
res = np;
}
*/
return res;
}
@Override
@NotNull
public AnnotationPlace chooseAnnotationsPlace(@NotNull final PsiElement element) {
if (!element.isPhysical()) return AnnotationPlace.IN_CODE; // element just created
if (!element.getManager().isInProject(element)) return AnnotationPlace.EXTERNAL;
final Project project = myPsiManager.getProject();
final PsiFile containingFile = element.getContainingFile();
final VirtualFile virtualFile = containingFile.getVirtualFile();
LOG.assertTrue(virtualFile != null);
final List<OrderEntry> entries =
ProjectRootManager.getInstance(project).getFileIndex().getOrderEntriesForFile(virtualFile);
if (!entries.isEmpty()) {
for (OrderEntry entry : entries) {
if (!(entry instanceof ModuleOrderEntry)) {
if (AnnotationOrderRootType.getUrls(entry).length > 0) {
return AnnotationPlace.EXTERNAL;
}
break;
}
}
}
final MyExternalPromptDialog dialog =
ApplicationManager.getApplication().isUnitTestMode()
|| ApplicationManager.getApplication().isHeadlessEnvironment()
? null
: new MyExternalPromptDialog(project);
if (dialog != null && dialog.isToBeShown()) {
final PsiElement highlightElement =
element instanceof PsiNameIdentifierOwner
? ((PsiNameIdentifierOwner) element).getNameIdentifier()
: element.getNavigationElement();
LOG.assertTrue(highlightElement != null);
final Editor editor = FileEditorManager.getInstance(project).getSelectedTextEditor();
final List<RangeHighlighter> highlighters = new ArrayList<RangeHighlighter>();
final boolean highlight =
editor != null
&& editor.getDocument()
== PsiDocumentManager.getInstance(project).getDocument(containingFile);
try {
if (highlight) { // do not highlight for batch inspections
final EditorColorsManager colorsManager = EditorColorsManager.getInstance();
final TextAttributes attributes =
colorsManager.getGlobalScheme().getAttributes(EditorColors.SEARCH_RESULT_ATTRIBUTES);
final TextRange textRange = highlightElement.getTextRange();
HighlightManager.getInstance(project)
.addRangeHighlight(
editor,
textRange.getStartOffset(),
textRange.getEndOffset(),
attributes,
true,
highlighters);
final LogicalPosition logicalPosition =
editor.offsetToLogicalPosition(textRange.getStartOffset());
editor.getScrollingModel().scrollTo(logicalPosition, ScrollType.CENTER);
}
dialog.show();
if (dialog.getExitCode() == 2) {
return AnnotationPlace.EXTERNAL;
} else if (dialog.getExitCode() == 1) {
return AnnotationPlace.NOWHERE;
}
} finally {
if (highlight) {
HighlightManager.getInstance(project)
.removeSegmentHighlighter(editor, highlighters.get(0));
}
}
} else if (dialog != null) {
dialog.close(DialogWrapper.OK_EXIT_CODE);
}
return AnnotationPlace.IN_CODE;
}
public static void verifyCaretAndSelectionState(
Editor editor, CaretAndSelectionState caretState, String message) {
boolean hasChecks = false;
for (int i = 0; i < caretState.carets.size(); i++) {
EditorTestUtil.CaretInfo expected = caretState.carets.get(i);
if (expected.position != null || expected.selection != null) {
hasChecks = true;
break;
}
}
if (!hasChecks) {
return; // nothing to check, so we skip caret/selection assertions
}
String messageSuffix = message == null ? "" : (message + ": ");
CaretModel caretModel = editor.getCaretModel();
List<Caret> allCarets = new ArrayList<Caret>(caretModel.getAllCarets());
assertEquals(
messageSuffix + " Unexpected number of carets", caretState.carets.size(), allCarets.size());
for (int i = 0; i < caretState.carets.size(); i++) {
String caretDescription =
caretState.carets.size() == 1
? ""
: "caret " + (i + 1) + "/" + caretState.carets.size() + " ";
Caret currentCaret = allCarets.get(i);
int actualCaretLine = editor.getDocument().getLineNumber(currentCaret.getOffset());
int actualCaretColumn =
currentCaret.getOffset() - editor.getDocument().getLineStartOffset(actualCaretLine);
LogicalPosition actualCaretPosition = new LogicalPosition(actualCaretLine, actualCaretColumn);
int selectionStart = currentCaret.getSelectionStart();
int selectionEnd = currentCaret.getSelectionEnd();
LogicalPosition actualSelectionStart = editor.offsetToLogicalPosition(selectionStart);
LogicalPosition actualSelectionEnd = editor.offsetToLogicalPosition(selectionEnd);
CaretInfo expected = caretState.carets.get(i);
if (expected.position != null) {
assertEquals(
messageSuffix + caretDescription + "unexpected caret position",
expected.position,
actualCaretPosition);
}
if (expected.selection != null) {
LogicalPosition expectedSelectionStart =
editor.offsetToLogicalPosition(expected.selection.getStartOffset());
LogicalPosition expectedSelectionEnd =
editor.offsetToLogicalPosition(expected.selection.getEndOffset());
assertEquals(
messageSuffix + caretDescription + "unexpected selection start",
expectedSelectionStart,
actualSelectionStart);
assertEquals(
messageSuffix + caretDescription + "unexpected selection end",
expectedSelectionEnd,
actualSelectionEnd);
} else {
assertFalse(
messageSuffix
+ caretDescription
+ "should has no selection, but was: ("
+ actualSelectionStart
+ ", "
+ actualSelectionEnd
+ ")",
currentCaret.hasSelection());
}
}
}
