private ProperTextRange offsetToYPosition(int start, int end) {
if (myEditorScrollbarTop == -1 || myEditorTargetHeight == -1) {
recalcEditorDimensions();
}
Document document = myEditor.getDocument();
int startLineNumber = offsetToLine(start, document);
int startY;
int lineCount;
if (myEditorSourceHeight < myEditorTargetHeight) {
lineCount = 0;
startY = myEditorScrollbarTop + startLineNumber * myEditor.getLineHeight();
} else {
lineCount = myEditorSourceHeight / myEditor.getLineHeight();
startY =
myEditorScrollbarTop + (int) ((float) startLineNumber / lineCount * myEditorTargetHeight);
}
int endY;
if (document.getLineNumber(start) == document.getLineNumber(end)) {
endY = startY; // both offsets are on the same line, no need to recalc Y position
} else {
int endLineNumber = offsetToLine(end, document);
if (myEditorSourceHeight < myEditorTargetHeight) {
endY = myEditorScrollbarTop + endLineNumber * myEditor.getLineHeight();
} else {
endY =
myEditorScrollbarTop + (int) ((float) endLineNumber / lineCount * myEditorTargetHeight);
}
if (endY < startY) endY = startY;
}
return new ProperTextRange(startY, endY);
}
@SuppressWarnings("ForLoopThatDoesntUseLoopVariable")
private static void indentPlainTextBlock(
final Document document, final int startOffset, final int endOffset, final int indentLevel) {
CharSequence chars = document.getCharsSequence();
int spaceEnd = CharArrayUtil.shiftForward(chars, startOffset, " \t");
int line = document.getLineNumber(startOffset);
if (spaceEnd > endOffset
|| indentLevel <= 0
|| line >= document.getLineCount() - 1
|| chars.charAt(spaceEnd) == '\n') {
return;
}
int linesToAdjustIndent = 0;
for (int i = line + 1; i < document.getLineCount(); i++) {
if (document.getLineStartOffset(i) >= endOffset) {
break;
}
linesToAdjustIndent++;
}
String indentString = StringUtil.repeatSymbol(' ', indentLevel);
for (; linesToAdjustIndent > 0; linesToAdjustIndent--) {
int lineStartOffset = document.getLineStartOffset(++line);
document.insertString(lineStartOffset, indentString);
}
}
private static void logInitial(
@NotNull Editor editor,
@NotNull int[] startOffsets,
@NotNull int[] endOffsets,
int indentSymbolsToStrip,
int firstLineStartOffset) {
if (!Registry.is("editor.richcopy.debug")) {
return;
}
StringBuilder buffer = new StringBuilder();
Document document = editor.getDocument();
CharSequence text = document.getCharsSequence();
for (int i = 0; i < startOffsets.length; i++) {
int start = startOffsets[i];
int lineStart = document.getLineStartOffset(document.getLineNumber(start));
int end = endOffsets[i];
int lineEnd = document.getLineEndOffset(document.getLineNumber(end));
buffer
.append(" region #")
.append(i)
.append(": ")
.append(start)
.append('-')
.append(end)
.append(", text at range ")
.append(lineStart)
.append('-')
.append(lineEnd)
.append(": \n'")
.append(text.subSequence(lineStart, lineEnd))
.append("'\n");
}
if (buffer.length() > 0) {
buffer.setLength(buffer.length() - 1);
}
LOG.info(
String.format(
"Preparing syntax-aware text. Given: %s selection, indent symbols to strip=%d, first line start offset=%d, selected text:%n%s",
startOffsets.length > 1 ? "block" : "regular",
indentSymbolsToStrip,
firstLineStartOffset,
buffer));
}
public static String getNewText(PsiElement elt) {
Project project = elt.getProject();
PsiFile psiFile = getContainingFile(elt);
final Document doc = PsiDocumentManager.getInstance(project).getDocument(psiFile);
if (doc == null) return null;
final ImplementationTextSelectioner implementationTextSelectioner =
LanguageImplementationTextSelectioner.INSTANCE.forLanguage(elt.getLanguage());
int start = implementationTextSelectioner.getTextStartOffset(elt);
final int end = implementationTextSelectioner.getTextEndOffset(elt);
final int lineStart = doc.getLineStartOffset(doc.getLineNumber(start));
final int lineEnd =
end < doc.getTextLength()
? doc.getLineEndOffset(doc.getLineNumber(end))
: doc.getTextLength();
return doc.getCharsSequence().subSequence(lineStart, lineEnd).toString();
}
private static Pair<Integer /* start offset to use */, Integer /* indent symbols to strip */>
calcIndentSymbolsToStrip(@NotNull Document document, int startOffset, int endOffset) {
int startLine = document.getLineNumber(startOffset);
int endLine = document.getLineNumber(endOffset);
CharSequence text = document.getCharsSequence();
int maximumCommonIndent = Integer.MAX_VALUE;
int firstLineStart = startOffset;
int firstLineEnd = startOffset;
for (int line = startLine; line <= endLine; line++) {
int lineStartOffset = document.getLineStartOffset(line);
int lineEndOffset = document.getLineEndOffset(line);
if (line == startLine) {
firstLineStart = lineStartOffset;
firstLineEnd = lineEndOffset;
}
int nonWsOffset = lineEndOffset;
for (int i = lineStartOffset;
i < lineEndOffset && (i - lineStartOffset) < maximumCommonIndent && i < endOffset;
i++) {
char c = text.charAt(i);
if (c != ' ' && c != '\t') {
nonWsOffset = i;
break;
}
}
if (nonWsOffset >= lineEndOffset) {
continue; // Blank line
}
int indent = nonWsOffset - lineStartOffset;
maximumCommonIndent = Math.min(maximumCommonIndent, indent);
if (maximumCommonIndent == 0) {
break;
}
}
int startOffsetToUse =
Math.min(firstLineEnd, Math.max(startOffset, firstLineStart + maximumCommonIndent));
return Pair.create(startOffsetToUse, maximumCommonIndent);
}
public void doClick(final MouseEvent e, final int width) {
RangeHighlighter marker = getNearestRangeHighlighter(e, width);
if (marker == null) return;
int offset = marker.getStartOffset();
final Document doc = myEditor.getDocument();
if (doc.getLineCount() > 0) {
// Necessary to expand folded block even if navigating just before one
// Very useful when navigating to first unused import statement.
int lineEnd = doc.getLineEndOffset(doc.getLineNumber(offset));
myEditor.getCaretModel().moveToOffset(lineEnd);
}
myEditor.getCaretModel().moveToOffset(offset);
myEditor.getSelectionModel().removeSelection();
ScrollingModel scrollingModel = myEditor.getScrollingModel();
scrollingModel.disableAnimation();
scrollingModel.scrollToCaret(ScrollType.CENTER);
scrollingModel.enableAnimation();
fireErrorMarkerClicked(marker, e);
}
public static String calcStringToFillVirtualSpace(Editor editor, int afterLineEnd) {
final Project project = editor.getProject();
StringBuilder buf = new StringBuilder();
final Document doc = editor.getDocument();
final int caretOffset = editor.getCaretModel().getOffset();
boolean atLineStart =
caretOffset >= doc.getTextLength()
|| doc.getLineStartOffset(doc.getLineNumber(caretOffset)) == caretOffset;
if (atLineStart && project != null) {
int offset = editor.getCaretModel().getOffset();
PsiDocumentManager.getInstance(project)
.commitDocument(doc); // Sync document and PSI before formatting.
String properIndent =
offset >= doc.getTextLength()
? ""
: CodeStyleFacade.getInstance(project).getLineIndent(doc, offset);
if (properIndent != null) {
int tabSize = editor.getSettings().getTabSize(project);
for (int i = 0; i < properIndent.length(); i++) {
if (properIndent.charAt(i) == ' ') {
afterLineEnd--;
} else if (properIndent.charAt(i) == '\t') {
if (afterLineEnd < tabSize) {
break;
}
afterLineEnd -= tabSize;
}
buf.append(properIndent.charAt(i));
if (afterLineEnd == 0) break;
}
}
}
for (int i = 0; i < afterLineEnd; i++) {
buf.append(' ');
}
return buf.toString();
}
private void paintHighlighterAfterEndOfLine(Graphics2D g, RangeHighlighterEx highlighter) {
if (!highlighter.isAfterEndOfLine()) {
return;
}
int startOffset = highlighter.getStartOffset();
int lineEndOffset = myDocument.getLineEndOffset(myDocument.getLineNumber(startOffset));
if (myEditor.getFoldingModel().isOffsetCollapsed(lineEndOffset)) return;
Point lineEnd = myView.offsetToXY(lineEndOffset, true, false);
int x = lineEnd.x;
int y = lineEnd.y;
TextAttributes attributes = highlighter.getTextAttributes();
paintBackground(g, attributes, x, y, myView.getPlainSpaceWidth());
if (attributes != null
&& hasTextEffect(attributes.getEffectColor(), attributes.getEffectType())) {
paintTextEffect(
g,
x,
x + myView.getPlainSpaceWidth() - 1,
y + myView.getAscent(),
attributes.getEffectColor(),
attributes.getEffectType());
}
}
private void paintLineMarkerSeparator(RangeHighlighter marker, Rectangle clip, Graphics g) {
Color separatorColor = marker.getLineSeparatorColor();
LineSeparatorRenderer lineSeparatorRenderer = marker.getLineSeparatorRenderer();
if (separatorColor == null && lineSeparatorRenderer == null) {
return;
}
int line =
myDocument.getLineNumber(
marker.getLineSeparatorPlacement() == SeparatorPlacement.TOP
? marker.getStartOffset()
: marker.getEndOffset());
int visualLine =
myView.logicalToVisualPosition(
new LogicalPosition(
line + (marker.getLineSeparatorPlacement() == SeparatorPlacement.TOP ? 0 : 1),
0),
false)
.line;
int y = myView.visualLineToY(visualLine) - 1;
int endShift = clip.x + clip.width;
EditorSettings settings = myEditor.getSettings();
if (settings.isRightMarginShown()
&& myEditor.getColorsScheme().getColor(EditorColors.RIGHT_MARGIN_COLOR) != null) {
endShift =
Math.min(
endShift,
settings.getRightMargin(myEditor.getProject()) * myView.getPlainSpaceWidth());
}
g.setColor(separatorColor);
if (lineSeparatorRenderer != null) {
lineSeparatorRenderer.drawLine(g, 0, endShift, y);
} else {
UIUtil.drawLine(g, 0, y, endShift, y);
}
}
public void doWrapLongLinesIfNecessary(
@NotNull final Editor editor,
@NotNull final Project project,
@NotNull Document document,
int startOffset,
int endOffset) {
// Normalization.
int startOffsetToUse = Math.min(document.getTextLength(), Math.max(0, startOffset));
int endOffsetToUse = Math.min(document.getTextLength(), Math.max(0, endOffset));
LineWrapPositionStrategy strategy = LanguageLineWrapPositionStrategy.INSTANCE.forEditor(editor);
CharSequence text = document.getCharsSequence();
int startLine = document.getLineNumber(startOffsetToUse);
int endLine = document.getLineNumber(Math.max(0, endOffsetToUse - 1));
int maxLine = Math.min(document.getLineCount(), endLine + 1);
int tabSize = EditorUtil.getTabSize(editor);
if (tabSize <= 0) {
tabSize = 1;
}
int spaceSize = EditorUtil.getSpaceWidth(Font.PLAIN, editor);
int[] shifts = new int[2];
// shifts[0] - lines shift.
// shift[1] - offset shift.
for (int line = startLine; line < maxLine; line++) {
int startLineOffset = document.getLineStartOffset(line);
int endLineOffset = document.getLineEndOffset(line);
final int preferredWrapPosition =
calculatePreferredWrapPosition(
editor, text, tabSize, spaceSize, startLineOffset, endLineOffset, endOffsetToUse);
if (preferredWrapPosition < 0 || preferredWrapPosition >= endLineOffset) {
continue;
}
if (preferredWrapPosition >= endOffsetToUse) {
return;
}
// We know that current line exceeds right margin if control flow reaches this place, so, wrap
// it.
int wrapOffset =
strategy.calculateWrapPosition(
document,
editor.getProject(),
Math.max(startLineOffset, startOffsetToUse),
Math.min(endLineOffset, endOffsetToUse),
preferredWrapPosition,
false,
false);
if (wrapOffset < 0 // No appropriate wrap position is found.
// No point in splitting line when its left part contains only white spaces, example:
// line start -> | | <- right margin
// | aaaaaaaaaaaaaaaa|aaaaaaaaaaaaaaaaaaaa() <- don't want to wrap this
// line even if it exceeds right margin
|| CharArrayUtil.shiftBackward(text, startLineOffset, wrapOffset - 1, " \t")
< startLineOffset) {
continue;
}
// Move caret to the target position and emulate pressing <enter>.
editor.getCaretModel().moveToOffset(wrapOffset);
emulateEnter(editor, project, shifts);
// We know that number of lines is just increased, hence, update the data accordingly.
maxLine += shifts[0];
endOffsetToUse += shifts[1];
}
}
private boolean insertDocAsterisk(
int lineStart,
boolean docAsterisk,
boolean previousLineIndentUsed,
CodeDocumentationAwareCommenter commenter) {
PsiElement atLineStart = myFile.findElementAt(lineStart);
if (atLineStart == null) return false;
final String linePrefix = commenter.getDocumentationCommentLinePrefix();
final String docPrefix = commenter.getDocumentationCommentPrefix();
final String text = atLineStart.getText();
final TextRange textRange = atLineStart.getTextRange();
if (text.equals(linePrefix)
|| text.equals(docPrefix)
|| docPrefix != null
&& text.regionMatches(
lineStart - textRange.getStartOffset(), docPrefix, 0, docPrefix.length())
|| linePrefix != null
&& text.regionMatches(
lineStart - textRange.getStartOffset(), linePrefix, 0, linePrefix.length())) {
PsiElement element = myFile.findElementAt(myOffset);
if (element == null) return false;
PsiComment comment =
element instanceof PsiComment
? (PsiComment) element
: PsiTreeUtil.getParentOfType(element, PsiComment.class, false);
if (comment != null) {
int commentEnd = comment.getTextRange().getEndOffset();
if (myOffset >= commentEnd) {
docAsterisk = false;
} else {
removeTrailingSpaces(myDocument, myOffset);
String toInsert =
previousLineIndentUsed
? "*"
: CodeDocumentationUtil.createDocCommentLine("", getProject(), commenter);
myDocument.insertString(myOffset, toInsert);
PsiDocumentManager.getInstance(getProject()).commitAllDocuments();
}
} else {
docAsterisk = false;
}
} else if (linePrefix != null
&& atLineStart instanceof PsiComment
&& ((PsiComment) atLineStart).getTokenType() == commenter.getBlockCommentTokenType()) {
// Check if C-Style comment already uses asterisks.
boolean usesAstersk = false;
int commentLine = myDocument.getLineNumber(textRange.getStartOffset());
if (commentLine < myDocument.getLineCount() - 1 && textRange.getEndOffset() >= myOffset) {
int nextLineOffset = myDocument.getLineStartOffset(commentLine + 1);
if (nextLineOffset < textRange.getEndOffset()) {
final CharSequence chars = myDocument.getCharsSequence();
nextLineOffset = CharArrayUtil.shiftForward(chars, nextLineOffset, " \t");
usesAstersk = CharArrayUtil.regionMatches(chars, nextLineOffset, linePrefix);
}
}
if (usesAstersk) {
removeTrailingSpaces(myDocument, myOffset);
myDocument.insertString(myOffset, linePrefix + " ");
PsiDocumentManager.getInstance(getProject()).commitAllDocuments();
}
docAsterisk = usesAstersk;
} else {
docAsterisk = false;
}
return docAsterisk;
}
@Override
public void invoke(
@NotNull Project project,
@NotNull Editor editor,
@NotNull Caret caret,
@NotNull PsiFile file) {
if (!CodeInsightUtilBase.prepareEditorForWrite(editor)) return;
myProject = project;
myEditor = editor;
myCaret = caret;
myFile = file;
myDocument = editor.getDocument();
if (!FileDocumentManager.getInstance().requestWriting(myDocument, project)) {
return;
}
FeatureUsageTracker.getInstance().triggerFeatureUsed("codeassists.comment.block");
final Commenter commenter = findCommenter(myFile, myEditor, caret);
if (commenter == null) return;
final String prefix;
final String suffix;
if (commenter instanceof SelfManagingCommenter) {
final SelfManagingCommenter selfManagingCommenter = (SelfManagingCommenter) commenter;
mySelfManagedCommenterData =
selfManagingCommenter.createBlockCommentingState(
caret.getSelectionStart(), caret.getSelectionEnd(), myDocument, myFile);
if (mySelfManagedCommenterData == null) {
mySelfManagedCommenterData = SelfManagingCommenter.EMPTY_STATE;
}
prefix =
selfManagingCommenter.getBlockCommentPrefix(
caret.getSelectionStart(), myDocument, mySelfManagedCommenterData);
suffix =
selfManagingCommenter.getBlockCommentSuffix(
caret.getSelectionEnd(), myDocument, mySelfManagedCommenterData);
} else {
prefix = commenter.getBlockCommentPrefix();
suffix = commenter.getBlockCommentSuffix();
}
if (prefix == null || suffix == null) return;
TextRange commentedRange = findCommentedRange(commenter);
if (commentedRange != null) {
final int commentStart = commentedRange.getStartOffset();
final int commentEnd = commentedRange.getEndOffset();
int selectionStart = commentStart;
int selectionEnd = commentEnd;
if (myCaret.hasSelection()) {
selectionStart = myCaret.getSelectionStart();
selectionEnd = myCaret.getSelectionEnd();
}
if ((commentStart < selectionStart || commentStart >= selectionEnd)
&& (commentEnd <= selectionStart || commentEnd > selectionEnd)) {
commentRange(selectionStart, selectionEnd, prefix, suffix, commenter);
} else {
uncommentRange(commentedRange, trim(prefix), trim(suffix), commenter);
}
} else {
if (myCaret.hasSelection()) {
int selectionStart = myCaret.getSelectionStart();
int selectionEnd = myCaret.getSelectionEnd();
if (commenter instanceof IndentedCommenter) {
final Boolean value = ((IndentedCommenter) commenter).forceIndentedLineComment();
if (value != null && value == Boolean.TRUE) {
selectionStart =
myDocument.getLineStartOffset(myDocument.getLineNumber(selectionStart));
selectionEnd = myDocument.getLineEndOffset(myDocument.getLineNumber(selectionEnd));
}
}
commentRange(selectionStart, selectionEnd, prefix, suffix, commenter);
} else {
EditorUtil.fillVirtualSpaceUntilCaret(editor);
int caretOffset = myCaret.getOffset();
if (commenter instanceof IndentedCommenter) {
final Boolean value = ((IndentedCommenter) commenter).forceIndentedLineComment();
if (value != null && value == Boolean.TRUE) {
final int lineNumber = myDocument.getLineNumber(caretOffset);
final int start = myDocument.getLineStartOffset(lineNumber);
final int end = myDocument.getLineEndOffset(lineNumber);
commentRange(start, end, prefix, suffix, commenter);
return;
}
}
myDocument.insertString(caretOffset, prefix + suffix);
myCaret.moveToOffset(caretOffset + prefix.length());
}
}
}
private static CompletionAssertions.WatchingInsertionContext insertItemHonorBlockSelection(
final CompletionProgressIndicator indicator,
final LookupElement item,
final char completionChar,
final List<LookupElement> items,
final CompletionLookupArranger.StatisticsUpdate update) {
final Editor editor = indicator.getEditor();
final int caretOffset = editor.getCaretModel().getOffset();
int idEndOffset = indicator.getIdentifierEndOffset();
if (idEndOffset < 0) {
idEndOffset = CompletionInitializationContext.calcDefaultIdentifierEnd(editor, caretOffset);
}
final int idEndOffsetDelta = idEndOffset - caretOffset;
CompletionAssertions.WatchingInsertionContext context = null;
if (editor.getSelectionModel().hasBlockSelection()
&& editor.getSelectionModel().getBlockSelectionEnds().length > 0) {
List<RangeMarker> insertionPoints = new ArrayList<RangeMarker>();
int idDelta = 0;
Document document = editor.getDocument();
int caretLine = document.getLineNumber(editor.getCaretModel().getOffset());
for (int point : editor.getSelectionModel().getBlockSelectionEnds()) {
insertionPoints.add(document.createRangeMarker(point, point));
if (document.getLineNumber(point) == document.getLineNumber(idEndOffset)) {
idDelta = idEndOffset - point;
}
}
List<RangeMarker> caretsAfter = new ArrayList<RangeMarker>();
for (RangeMarker marker : insertionPoints) {
if (marker.isValid()) {
int insertionPoint = marker.getStartOffset();
context =
insertItem(
indicator,
item,
completionChar,
items,
update,
editor,
indicator.getParameters().getOriginalFile(),
insertionPoint,
idDelta + insertionPoint);
int offset = editor.getCaretModel().getOffset();
caretsAfter.add(document.createRangeMarker(offset, offset));
}
}
assert context != null;
restoreBlockSelection(editor, caretsAfter, caretLine);
for (RangeMarker insertionPoint : insertionPoints) {
insertionPoint.dispose();
}
for (RangeMarker marker : caretsAfter) {
marker.dispose();
}
} else if (editor.getCaretModel().supportsMultipleCarets()) {
final List<CompletionAssertions.WatchingInsertionContext> contexts =
new ArrayList<CompletionAssertions.WatchingInsertionContext>();
final Editor hostEditor = InjectedLanguageUtil.getTopLevelEditor(editor);
hostEditor
.getCaretModel()
.runForEachCaret(
new CaretAction() {
@Override
public void perform(Caret caret) {
PsiFile hostFile =
InjectedLanguageUtil.getTopLevelFile(
indicator.getParameters().getOriginalFile());
PsiFile targetFile =
InjectedLanguageUtil.findInjectedPsiNoCommit(hostFile, caret.getOffset());
Editor targetEditor =
InjectedLanguageUtil.getInjectedEditorForInjectedFile(hostEditor, targetFile);
int targetCaretOffset = targetEditor.getCaretModel().getOffset();
CompletionAssertions.WatchingInsertionContext currentContext =
insertItem(
indicator,
item,
completionChar,
items,
update,
targetEditor,
targetFile == null ? hostFile : targetFile,
targetCaretOffset,
targetCaretOffset + idEndOffsetDelta);
contexts.add(currentContext);
}
},
true);
context = contexts.get(contexts.size() - 1);
if (context.shouldAddCompletionChar()
&& context.getCompletionChar() != Lookup.COMPLETE_STATEMENT_SELECT_CHAR) {
ApplicationManager.getApplication()
.runWriteAction(
new Runnable() {
@Override
public void run() {
DataContext dataContext =
DataManager.getInstance().getDataContext(editor.getContentComponent());
EditorActionManager.getInstance()
.getTypedAction()
.getHandler()
.execute(editor, completionChar, dataContext);
}
});
}
for (CompletionAssertions.WatchingInsertionContext insertionContext : contexts) {
insertionContext.stopWatching();
}
} else {
context =
insertItem(
indicator,
item,
completionChar,
items,
update,
editor,
indicator.getParameters().getOriginalFile(),
caretOffset,
idEndOffset);
}
return context;
}
private void doComment() {
myStartLine = myDocument.getLineNumber(myStartOffset);
myEndLine = myDocument.getLineNumber(myEndOffset);
if (myEndLine > myStartLine && myDocument.getLineStartOffset(myEndLine) == myEndOffset) {
myEndLine--;
}
myStartOffsets = new int[myEndLine - myStartLine + 1];
myEndOffsets = new int[myEndLine - myStartLine + 1];
myCommenters = new Commenter[myEndLine - myStartLine + 1];
myCommenterStateMap = new THashMap<SelfManagingCommenter, CommenterDataHolder>();
CharSequence chars = myDocument.getCharsSequence();
boolean singleline = myStartLine == myEndLine;
int offset = myDocument.getLineStartOffset(myStartLine);
offset = CharArrayUtil.shiftForward(myDocument.getCharsSequence(), offset, " \t");
final Language languageSuitableForCompleteFragment =
PsiUtilBase.reallyEvaluateLanguageInRange(
offset,
CharArrayUtil.shiftBackward(
myDocument.getCharsSequence(), myDocument.getLineEndOffset(myEndLine), " \t\n"),
myFile);
Commenter blockSuitableCommenter =
languageSuitableForCompleteFragment == null
? LanguageCommenters.INSTANCE.forLanguage(myFile.getLanguage())
: null;
if (blockSuitableCommenter == null && myFile.getFileType() instanceof AbstractFileType) {
blockSuitableCommenter =
new Commenter() {
final SyntaxTable mySyntaxTable =
((AbstractFileType) myFile.getFileType()).getSyntaxTable();
@Nullable
public String getLineCommentPrefix() {
return mySyntaxTable.getLineComment();
}
@Nullable
public String getBlockCommentPrefix() {
return mySyntaxTable.getStartComment();
}
@Nullable
public String getBlockCommentSuffix() {
return mySyntaxTable.getEndComment();
}
public String getCommentedBlockCommentPrefix() {
return null;
}
public String getCommentedBlockCommentSuffix() {
return null;
}
};
}
boolean allLineCommented = true;
boolean commentWithIndent =
!CodeStyleSettingsManager.getSettings(myProject).LINE_COMMENT_AT_FIRST_COLUMN;
for (int line = myStartLine; line <= myEndLine; line++) {
Commenter commenter =
blockSuitableCommenter != null ? blockSuitableCommenter : findCommenter(line);
if (commenter == null) return;
if (commenter.getLineCommentPrefix() == null
&& (commenter.getBlockCommentPrefix() == null
|| commenter.getBlockCommentSuffix() == null)) {
return;
}
if (commenter instanceof SelfManagingCommenter
&& myCommenterStateMap.get(commenter) == null) {
final SelfManagingCommenter selfManagingCommenter = (SelfManagingCommenter) commenter;
CommenterDataHolder state =
selfManagingCommenter.createLineCommentingState(
myStartLine, myEndLine, myDocument, myFile);
if (state == null) state = SelfManagingCommenter.EMPTY_STATE;
myCommenterStateMap.put(selfManagingCommenter, state);
}
myCommenters[line - myStartLine] = commenter;
if (!isLineCommented(line, chars, commenter) && (singleline || !isLineEmpty(line))) {
allLineCommented = false;
if (commenter instanceof IndentedCommenter) {
final Boolean value = ((IndentedCommenter) commenter).forceIndentedLineComment();
if (value != null) {
commentWithIndent = value;
}
}
break;
}
}
if (!allLineCommented) {
if (!commentWithIndent) {
doDefaultCommenting(blockSuitableCommenter);
} else {
doIndentCommenting(blockSuitableCommenter);
}
} else {
for (int line = myEndLine; line >= myStartLine; line--) {
uncommentLine(line);
// int offset1 = myStartOffsets[line - myStartLine];
// int offset2 = myEndOffsets[line - myStartLine];
// if (offset1 == offset2) continue;
// Commenter commenter = myCommenters[line - myStartLine];
// String prefix = commenter.getBlockCommentPrefix();
// if (prefix == null || !myDocument.getText().substring(offset1,
// myDocument.getTextLength()).startsWith(prefix)) {
// prefix = commenter.getLineCommentPrefix();
// }
//
// String suffix = commenter.getBlockCommentSuffix();
// if (suffix == null && prefix != null) suffix = "";
//
// if (prefix != null && suffix != null) {
// final int suffixLen = suffix.length();
// final int prefixLen = prefix.length();
// if (offset2 >= 0) {
// if (!CharArrayUtil.regionMatches(chars, offset1 + prefixLen, prefix)) {
// myDocument.deleteString(offset2 - suffixLen, offset2);
// }
// }
// if (offset1 >= 0) {
// for (int i = offset2 - suffixLen - 1; i > offset1 + prefixLen; --i) {
// if (CharArrayUtil.regionMatches(chars, i, suffix)) {
// myDocument.deleteString(i, i + suffixLen);
// }
// else if (CharArrayUtil.regionMatches(chars, i, prefix)) {
// myDocument.deleteString(i, i + prefixLen);
// }
// }
// myDocument.deleteString(offset1, offset1 + prefixLen);
// }
// }
}
}
}
public void invoke(@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) {
myProject = project;
myFile = file.getViewProvider().getPsi(file.getViewProvider().getBaseLanguage());
myEditor = editor;
PsiElement context = myFile.getContext();
if (context != null && (context.textContains('\'') || context.textContains('\"'))) {
String s = context.getText();
if (StringUtil.startsWith(s, "\"") || StringUtil.startsWith(s, "\'")) {
myFile = context.getContainingFile();
myEditor = editor instanceof EditorWindow ? ((EditorWindow) editor).getDelegate() : editor;
}
}
myDocument = myEditor.getDocument();
if (!FileDocumentManager.getInstance().requestWriting(myDocument, project)) {
return;
}
PsiDocumentManager.getInstance(project).commitDocument(myDocument);
FeatureUsageTracker.getInstance().triggerFeatureUsed("codeassists.comment.line");
myCodeStyleManager = CodeStyleManager.getInstance(myProject);
final SelectionModel selectionModel = myEditor.getSelectionModel();
boolean hasSelection = selectionModel.hasSelection();
myStartOffset = selectionModel.getSelectionStart();
myEndOffset = selectionModel.getSelectionEnd();
FoldRegion fold = myEditor.getFoldingModel().getCollapsedRegionAtOffset(myStartOffset);
if (fold != null
&& fold.shouldNeverExpand()
&& fold.getStartOffset() == myStartOffset
&& fold.getEndOffset() == myEndOffset) {
// Foldings that never expand are automatically selected, so the fact it is selected must not
// interfer with commenter's logic
hasSelection = false;
}
if (myDocument.getTextLength() == 0) return;
while (true) {
int lastLineEnd = myDocument.getLineEndOffset(myDocument.getLineNumber(myEndOffset));
FoldRegion collapsedAt = myEditor.getFoldingModel().getCollapsedRegionAtOffset(lastLineEnd);
if (collapsedAt != null) {
final int endOffset = collapsedAt.getEndOffset();
if (endOffset <= myEndOffset) {
break;
}
myEndOffset = endOffset;
} else {
break;
}
}
boolean wholeLinesSelected =
!hasSelection
|| myStartOffset
== myDocument.getLineStartOffset(myDocument.getLineNumber(myStartOffset))
&& myEndOffset
== myDocument.getLineEndOffset(myDocument.getLineNumber(myEndOffset - 1)) + 1;
boolean startingNewLineComment =
!hasSelection
&& isLineEmpty(myDocument.getLineNumber(myStartOffset))
&& !Comparing.equal(
IdeActions.ACTION_COMMENT_LINE,
ActionManagerEx.getInstanceEx().getPrevPreformedActionId());
doComment();
if (startingNewLineComment) {
final Commenter commenter = myCommenters[0];
if (commenter != null) {
String prefix;
if (commenter instanceof SelfManagingCommenter) {
prefix =
((SelfManagingCommenter) commenter)
.getCommentPrefix(
myStartLine,
myDocument,
myCommenterStateMap.get((SelfManagingCommenter) commenter));
if (prefix == null) prefix = ""; // TODO
} else {
prefix = commenter.getLineCommentPrefix();
if (prefix == null) prefix = commenter.getBlockCommentPrefix();
}
int lineStart = myDocument.getLineStartOffset(myStartLine);
lineStart = CharArrayUtil.shiftForward(myDocument.getCharsSequence(), lineStart, " \t");
lineStart += prefix.length();
lineStart = CharArrayUtil.shiftForward(myDocument.getCharsSequence(), lineStart, " \t");
if (lineStart > myDocument.getTextLength()) lineStart = myDocument.getTextLength();
myEditor.getCaretModel().moveToOffset(lineStart);
myEditor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
}
} else {
if (!hasSelection) {
// Don't tweak caret position if we're already located on the last document line.
LogicalPosition position = myEditor.getCaretModel().getLogicalPosition();
if (position.line < myDocument.getLineCount() - 1) {
int verticalShift =
1
+ myEditor.getSoftWrapModel().getSoftWrapsForLine(position.line).size()
- position.softWrapLinesOnCurrentLogicalLine;
myEditor.getCaretModel().moveCaretRelatively(0, verticalShift, false, false, true);
}
} else {
if (wholeLinesSelected) {
selectionModel.setSelection(myStartOffset, selectionModel.getSelectionEnd());
}
}
}
}
private static CompletionAssertions.WatchingInsertionContext insertItemHonorBlockSelection(
final CompletionProgressIndicator indicator,
final LookupElement item,
final char completionChar,
final List<LookupElement> items,
final CompletionLookupArranger.StatisticsUpdate update) {
final Editor editor = indicator.getEditor();
final int caretOffset = editor.getCaretModel().getOffset();
int idEndOffset = indicator.getIdentifierEndOffset();
if (idEndOffset < 0) {
idEndOffset = CompletionInitializationContext.calcDefaultIdentifierEnd(editor, caretOffset);
}
final int idEndOffsetDelta = idEndOffset - caretOffset;
CompletionAssertions.WatchingInsertionContext context = null;
if (editor.getSelectionModel().hasBlockSelection()
&& editor.getSelectionModel().getBlockSelectionEnds().length > 0) {
List<RangeMarker> insertionPoints = new ArrayList<RangeMarker>();
int idDelta = 0;
Document document = editor.getDocument();
int caretLine = document.getLineNumber(editor.getCaretModel().getOffset());
for (int point : editor.getSelectionModel().getBlockSelectionEnds()) {
insertionPoints.add(document.createRangeMarker(point, point));
if (document.getLineNumber(point) == document.getLineNumber(idEndOffset)) {
idDelta = idEndOffset - point;
}
}
List<RangeMarker> caretsAfter = new ArrayList<RangeMarker>();
for (RangeMarker marker : insertionPoints) {
if (marker.isValid()) {
int insertionPoint = marker.getStartOffset();
context =
insertItem(
indicator,
item,
completionChar,
items,
update,
editor,
insertionPoint,
idDelta + insertionPoint);
int offset = editor.getCaretModel().getOffset();
caretsAfter.add(document.createRangeMarker(offset, offset));
}
}
assert context != null;
restoreBlockSelection(editor, caretsAfter, caretLine);
for (RangeMarker insertionPoint : insertionPoints) {
insertionPoint.dispose();
}
for (RangeMarker marker : caretsAfter) {
marker.dispose();
}
} else {
final Ref<CompletionAssertions.WatchingInsertionContext> contextRef =
new Ref<CompletionAssertions.WatchingInsertionContext>();
editor
.getCaretModel()
.runForEachCaret(
new CaretAction() {
@Override
public void perform(Caret caret) {
CompletionAssertions.WatchingInsertionContext currentContext =
insertItem(
indicator,
item,
completionChar,
items,
update,
editor,
caret.getOffset(),
caret.getOffset() + idEndOffsetDelta);
if (caret
.getVisualPosition()
.equals(editor.getCaretModel().getPrimaryCaret().getVisualPosition())) {
contextRef.set(currentContext);
}
}
});
context = contextRef.get();
}
return context;
}
@Override
public void run() {
CaretModel caretModel = myEditor.getCaretModel();
try {
final CharSequence chars = myDocument.getCharsSequence();
int i = CharArrayUtil.shiftBackwardUntil(chars, myOffset - 1, LINE_SEPARATOR) - 1;
i = CharArrayUtil.shiftBackwardUntil(chars, i, LINE_SEPARATOR) + 1;
if (i < 0) i = 0;
int lineStart = CharArrayUtil.shiftForward(chars, i, " \t");
CodeDocumentationUtil.CommentContext commentContext =
CodeDocumentationUtil.tryParseCommentContext(myFile, chars, myOffset, lineStart);
PsiDocumentManager psiDocumentManager = PsiDocumentManager.getInstance(getProject());
if (commentContext.docStart) {
PsiElement element = myFile.findElementAt(commentContext.lineStart);
final String text = element.getText();
final PsiElement parent = element.getParent();
if (text.equals(commentContext.commenter.getDocumentationCommentPrefix())
&& isDocComment(parent, commentContext.commenter)
|| text.startsWith(commentContext.commenter.getDocumentationCommentPrefix())
&& element instanceof PsiComment) {
PsiComment comment =
isDocComment(parent, commentContext.commenter)
? (PsiComment) parent
: (PsiComment) element;
int commentEnd = comment.getTextRange().getEndOffset();
if (myOffset >= commentEnd) {
commentContext.docStart = false;
} else {
if (isCommentComplete(comment, commentContext.commenter, myEditor)) {
if (myOffset >= commentEnd) {
commentContext.docAsterisk = false;
commentContext.docStart = false;
} else {
commentContext.docAsterisk = true;
commentContext.docStart = false;
}
} else {
generateJavadoc(commentContext.commenter);
}
}
} else {
commentContext.docStart = false;
}
} else if (commentContext.cStyleStart) {
PsiElement element = myFile.findElementAt(commentContext.lineStart);
if (element instanceof PsiComment
&& commentContext.commenter.getBlockCommentTokenType()
== ((PsiComment) element).getTokenType()) {
final PsiComment comment = (PsiComment) element;
int commentEnd = comment.getTextRange().getEndOffset();
if (myOffset >= commentEnd && myOffset < myFile.getTextRange().getEndOffset()) {
commentContext.docStart = false;
} else {
if (isCommentComplete(comment, commentContext.commenter, myEditor)) {
if (myOffset >= commentEnd) {
commentContext.docAsterisk = false;
commentContext.docStart = false;
} else {
commentContext.docAsterisk = true;
commentContext.docStart = false;
}
} else {
final int currentEndOfLine = CharArrayUtil.shiftForwardUntil(chars, myOffset, "\n");
myDocument.insertString(
currentEndOfLine, " " + commentContext.commenter.getBlockCommentSuffix());
int lstart = CharArrayUtil.shiftBackwardUntil(chars, myOffset, "\n");
myDocument.insertString(currentEndOfLine, chars.subSequence(lstart, myOffset));
psiDocumentManager.commitDocument(myDocument);
}
}
} else {
commentContext.docStart = false;
}
}
String indentInsideJavadoc = null;
if (myOffset < myDocument.getTextLength()) {
final int line = myDocument.getLineNumber(myOffset);
if (line > 0 && (commentContext.docAsterisk || commentContext.docStart)) {
indentInsideJavadoc =
CodeDocumentationUtil.getIndentInsideJavadoc(
myDocument, myDocument.getLineStartOffset(line - 1));
}
}
if (commentContext.docAsterisk) {
commentContext.docAsterisk =
insertDocAsterisk(
commentContext.lineStart,
commentContext.docAsterisk,
!StringUtil.isEmpty(indentInsideJavadoc),
commentContext.commenter);
}
boolean docIndentApplied = false;
CodeInsightSettings codeInsightSettings = CodeInsightSettings.getInstance();
if (codeInsightSettings.SMART_INDENT_ON_ENTER
|| myForceIndent
|| commentContext.docStart
|| commentContext.docAsterisk
|| commentContext.slashSlash) {
final CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(getProject());
myOffset = codeStyleManager.adjustLineIndent(myFile, myOffset);
psiDocumentManager.commitAllDocuments();
if (!StringUtil.isEmpty(indentInsideJavadoc) && myOffset < myDocument.getTextLength()) {
myDocument.insertString(myOffset + 1, indentInsideJavadoc);
myOffset += indentInsideJavadoc.length();
docIndentApplied = true;
}
if (myForceIndent && indentInsideJavadoc != null) {
int indentSize =
CodeStyleSettingsManager.getSettings(myProject).getIndentSize(myFile.getFileType());
myDocument.insertString(myOffset + 1, StringUtil.repeatSymbol(' ', indentSize));
myCaretAdvance += indentSize;
}
}
if ((commentContext.docAsterisk || commentContext.docStart || commentContext.slashSlash)
&& !docIndentApplied) {
if (myInsertSpace) {
if (myOffset == myDocument.getTextLength()) {
myDocument.insertString(myOffset, " ");
}
myDocument.insertString(myOffset + 1, " ");
}
final char c = myDocument.getCharsSequence().charAt(myOffset);
if (c != '\n') {
myOffset += 1;
}
}
if ((commentContext.docAsterisk || commentContext.slashSlash) && !commentContext.docStart) {
myCaretAdvance +=
commentContext.slashSlash
? commentContext.commenter.getLineCommentPrefix().length()
: 1;
}
} catch (IncorrectOperationException e) {
LOG.error(e);
}
myOffset = Math.min(myOffset, myDocument.getTextLength());
caretModel.moveToOffset(myOffset);
myEditor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
myEditor.getSelectionModel().removeSelection();
if (myCaretAdvance != 0) {
LogicalPosition caretPosition = caretModel.getLogicalPosition();
LogicalPosition pos =
new LogicalPosition(caretPosition.line, caretPosition.column + myCaretAdvance);
caretModel.moveToLogicalPosition(pos);
}
}
private void generateJavadoc(CodeDocumentationAwareCommenter commenter)
throws IncorrectOperationException {
CodeInsightSettings settings = CodeInsightSettings.getInstance();
StringBuilder buffer = new StringBuilder();
final String docCommentLinePrefix = commenter.getDocumentationCommentLinePrefix();
if (docCommentLinePrefix == null) {
return;
}
// There are at least two approaches for completing javadoc in case there is a text between
// current caret position and line end:
// 1. Move that tail text below the javadoc. Use-case:
// Before:
// /**<caret>public void foo() {}
// After:
// /**
// */
// public void foo() {}
// 2. Move the tail text inside the javadoc. Use-case:
// Before:
// /**This is <caret>javadoc description
// After:
// /** This is
// * javadoc description
// */
// The later is most relevant when we have 'auto wrap when typing reaches right margin' option
// set, i.e. user starts javadoc
// and types until right margin is reached. We want the wrapped text tail to be located inside
// javadoc and continue typing
// inside it. So, we have a control flow branch below that does the trick.
buffer.append(docCommentLinePrefix);
if (DataManager.getInstance()
.loadFromDataContext(
myDataContext, AutoHardWrapHandler.AUTO_WRAP_LINE_IN_PROGRESS_KEY)
== Boolean.TRUE) {
myDocument.insertString(myOffset, buffer);
// We create new buffer here because the one referenced by current 'buffer' variable value
// may be already referenced at another
// place (e.g. 'undo' processing stuff).
buffer =
new StringBuilder(LINE_SEPARATOR).append(commenter.getDocumentationCommentSuffix());
int line = myDocument.getLineNumber(myOffset);
myOffset = myDocument.getLineEndOffset(line);
} else {
buffer.append(LINE_SEPARATOR);
buffer.append(commenter.getDocumentationCommentSuffix());
}
PsiComment comment = createComment(buffer, settings);
if (comment == null) {
return;
}
myOffset = comment.getTextRange().getStartOffset();
CharSequence text = myDocument.getCharsSequence();
myOffset = CharArrayUtil.shiftForwardUntil(text, myOffset, LINE_SEPARATOR);
myOffset = CharArrayUtil.shiftForward(text, myOffset, LINE_SEPARATOR);
myOffset = CharArrayUtil.shiftForwardUntil(text, myOffset, docCommentLinePrefix) + 1;
removeTrailingSpaces(myDocument, myOffset);
if (!CodeStyleSettingsManager.getSettings(getProject()).JD_LEADING_ASTERISKS_ARE_ENABLED) {
LOG.assertTrue(
CharArrayUtil.regionMatches(
myDocument.getCharsSequence(),
myOffset - docCommentLinePrefix.length(),
docCommentLinePrefix));
myDocument.deleteString(myOffset - docCommentLinePrefix.length(), myOffset);
myOffset--;
} else {
myDocument.insertString(myOffset, " ");
myOffset++;
}
PsiDocumentManager.getInstance(getProject()).commitAllDocuments();
}
private void paintBorderEffect(
Graphics2D g,
ClipDetector clipDetector,
int startOffset,
int endOffset,
TextAttributes attributes) {
if (!clipDetector.rangeCanBeVisible(startOffset, endOffset)) return;
int startLine = myDocument.getLineNumber(startOffset);
int endLine = myDocument.getLineNumber(endOffset);
if (startLine + 1 == endLine
&& startOffset == myDocument.getLineStartOffset(startLine)
&& endOffset == myDocument.getLineStartOffset(endLine)) {
// special case of line highlighters
endLine--;
endOffset = myDocument.getLineEndOffset(endLine);
}
boolean rounded = attributes.getEffectType() == EffectType.ROUNDED_BOX;
int lineHeight = myView.getLineHeight() - 1;
g.setColor(attributes.getEffectColor());
VisualPosition startPosition = myView.offsetToVisualPosition(startOffset, true, false);
VisualPosition endPosition = myView.offsetToVisualPosition(endOffset, false, true);
if (startPosition.line == endPosition.line) {
int y = myView.visualLineToY(startPosition.line);
TFloatArrayList ranges = adjustedLogicalRangeToVisualRanges(startOffset, endOffset);
for (int i = 0; i < ranges.size() - 1; i += 2) {
int startX = (int) ranges.get(i);
int endX = (int) ranges.get(i + 1);
if (rounded) {
UIUtil.drawRectPickedOut(g, startX, y, endX - startX, lineHeight);
} else {
g.drawRect(startX, y, endX - startX, lineHeight);
}
}
} else {
int maxWidth = myView.getMaxWidthInLineRange(startPosition.line, endPosition.line) - 1;
TFloatArrayList leadingRanges =
adjustedLogicalRangeToVisualRanges(
startOffset,
myView.visualPositionToOffset(
new VisualPosition(startPosition.line, Integer.MAX_VALUE, true)));
TFloatArrayList trailingRanges =
adjustedLogicalRangeToVisualRanges(
myView.visualPositionToOffset(new VisualPosition(endPosition.line, 0)), endOffset);
if (!leadingRanges.isEmpty() && !trailingRanges.isEmpty()) {
boolean containsInnerLines = endPosition.line > startPosition.line + 1;
int leadingTopY = myView.visualLineToY(startPosition.line);
int leadingBottomY = leadingTopY + lineHeight;
int trailingTopY = myView.visualLineToY(endPosition.line);
int trailingBottomY = trailingTopY + lineHeight;
float start = 0;
float end = 0;
float leftGap = leadingRanges.get(0) - (containsInnerLines ? 0 : trailingRanges.get(0));
int adjustY =
leftGap == 0 ? 2 : leftGap > 0 ? 1 : 0; // avoiding 1-pixel gap between aligned lines
for (int i = 0; i < leadingRanges.size() - 1; i += 2) {
start = leadingRanges.get(i);
end = leadingRanges.get(i + 1);
if (i > 0) {
drawLine(g, leadingRanges.get(i - 1), leadingBottomY, start, leadingBottomY, rounded);
}
drawLine(g, start, leadingBottomY + (i == 0 ? adjustY : 0), start, leadingTopY, rounded);
if ((i + 2) < leadingRanges.size()) {
drawLine(g, start, leadingTopY, end, leadingTopY, rounded);
drawLine(g, end, leadingTopY, end, leadingBottomY, rounded);
}
}
end = Math.max(end, maxWidth);
drawLine(g, start, leadingTopY, end, leadingTopY, rounded);
drawLine(g, end, leadingTopY, end, trailingTopY - 1, rounded);
float targetX = trailingRanges.get(trailingRanges.size() - 1);
drawLine(g, end, trailingTopY - 1, targetX, trailingTopY - 1, rounded);
adjustY =
end == targetX
? -2
: -1; // for lastX == targetX we need to avoid a gap when rounding is used
for (int i = trailingRanges.size() - 2; i >= 0; i -= 2) {
start = trailingRanges.get(i);
end = trailingRanges.get(i + 1);
drawLine(g, end, trailingTopY + (i == 0 ? adjustY : 0), end, trailingBottomY, rounded);
drawLine(g, end, trailingBottomY, start, trailingBottomY, rounded);
drawLine(g, start, trailingBottomY, start, trailingTopY, rounded);
if (i > 0) {
drawLine(g, start, trailingTopY, trailingRanges.get(i - 1), trailingTopY, rounded);
}
}
float lastX = start;
if (containsInnerLines) {
if (start > 0) {
drawLine(g, start, trailingTopY, start, trailingTopY - 1, rounded);
drawLine(g, start, trailingTopY - 1, 0, trailingTopY - 1, rounded);
drawLine(g, 0, trailingTopY - 1, 0, leadingBottomY + 1, rounded);
} else {
drawLine(g, start, trailingTopY, 0, leadingBottomY + 1, rounded);
}
lastX = 0;
}
targetX = leadingRanges.get(0);
if (lastX < targetX) {
drawLine(g, lastX, leadingBottomY + 1, targetX, leadingBottomY + 1, rounded);
} else {
drawLine(g, lastX, leadingBottomY + 1, lastX, leadingBottomY, rounded);
drawLine(g, lastX, leadingBottomY, targetX, leadingBottomY, rounded);
}
}
}
}
private static void indentBlockWithFormatter(
Project project, Document document, int startOffset, int endOffset, PsiFile file) {
// Algorithm: the main idea is to process the first line of the pasted block, adjust its indent
// if necessary, calculate indent
// adjustment string and apply to each line of the pasted block starting from the second one.
//
// We differentiate the following possible states here:
// --- pasted block doesn't start new line, i.e. there are non-white space symbols before it
// at the first line.
// Example:
// old content [pasted line 1
// pasted line 2]
// Indent adjustment string is just the first line indent then.
//
// --- pasted block starts with empty line(s)
// Example:
// old content [
// pasted line 1
// pasted line 2]
// We parse existing indents of the pasted block then, adjust its first non-blank line via
// formatter and adjust indent
// of subsequent pasted lines in order to preserve old indentation.
//
// --- pasted block is located at the new line and starts with white space symbols.
// Example:
// [ pasted line 1
// pasted line 2]
// We parse existing indents of the pasted block then, adjust its first line via formatter
// and adjust indent of the pasted lines
// starting from the second one in order to preserve old indentation.
//
// --- pasted block is located at the new line but doesn't start with white space symbols.
// Example:
// [pasted line 1
// pasted line 2]
// We adjust the first line via formatter then and apply first line's indent to all
// subsequent pasted lines.
CharSequence chars = document.getCharsSequence();
final int firstLine = document.getLineNumber(startOffset);
final int firstLineStart = document.getLineStartOffset(firstLine);
// There is a possible case that we paste block that ends with new line that is empty or
// contains only white space symbols.
// We want to preserve indent for the original document line where paste was performed.
// Example:
// Original:
// if (test) {
// <caret> }
//
// Pasting: 'int i = 1;\n'
// Expected:
// if (test) {
// int i = 1;
// }
boolean saveLastLineIndent = false;
for (int i = endOffset - 1; i >= startOffset; i--) {
final char c = chars.charAt(i);
if (c == '\n') {
saveLastLineIndent = true;
break;
}
if (c != ' ' && c != '\t') {
break;
}
}
final int lastLine;
if (saveLastLineIndent) {
lastLine = document.getLineNumber(endOffset) - 1;
// Remove white space symbols at the pasted text if any.
int start = document.getLineStartOffset(lastLine + 1);
if (start < endOffset) {
int i = CharArrayUtil.shiftForward(chars, start, " \t");
if (i > start) {
i = Math.min(i, endOffset);
document.deleteString(start, i);
}
}
// Insert white space from the start line of the pasted block.
int indentToKeepEndOffset =
Math.min(startOffset, CharArrayUtil.shiftForward(chars, firstLineStart, " \t"));
if (indentToKeepEndOffset > firstLineStart) {
document.insertString(start, chars.subSequence(firstLineStart, indentToKeepEndOffset));
}
} else {
lastLine = document.getLineNumber(endOffset);
}
final int i = CharArrayUtil.shiftBackward(chars, startOffset - 1, " \t");
// Handle a situation when pasted block doesn't start a new line.
if (chars.charAt(startOffset) != '\n' && i > 0 && chars.charAt(i) != '\n') {
int firstNonWsOffset = CharArrayUtil.shiftForward(chars, firstLineStart, " \t");
if (firstNonWsOffset > firstLineStart) {
CharSequence toInsert = chars.subSequence(firstLineStart, firstNonWsOffset);
for (int line = firstLine + 1; line <= lastLine; line++) {
document.insertString(document.getLineStartOffset(line), toInsert);
}
}
return;
}
// Sync document and PSI for correct formatting processing.
PsiDocumentManager.getInstance(project).commitAllDocuments();
if (file == null) {
return;
}
CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(project);
final int j = CharArrayUtil.shiftForward(chars, startOffset, " \t\n");
if (j >= endOffset) {
// Pasted text contains white space/line feed symbols only, do nothing.
return;
}
final int anchorLine = document.getLineNumber(j);
final int anchorLineStart = document.getLineStartOffset(anchorLine);
codeStyleManager.adjustLineIndent(file, j);
// Handle situation when pasted block starts with non-white space symbols.
if (anchorLine == firstLine && j == startOffset) {
int indentOffset = CharArrayUtil.shiftForward(chars, firstLineStart, " \t");
if (indentOffset > firstLineStart) {
CharSequence toInsert = chars.subSequence(firstLineStart, indentOffset);
for (int line = firstLine + 1; line <= lastLine; line++) {
document.insertString(document.getLineStartOffset(line), toInsert);
}
}
return;
}
// Handle situation when pasted block starts from white space symbols. Assume that the pasted
// text started at the line start,
// i.e. correct indentation level is stored at the blocks structure.
final int firstNonWsOffset = CharArrayUtil.shiftForward(chars, anchorLineStart, " \t");
final int diff = firstNonWsOffset - j;
if (diff == 0) {
return;
}
if (diff > 0) {
CharSequence toInsert = chars.subSequence(anchorLineStart, anchorLineStart + diff);
for (int line = anchorLine + 1; line <= lastLine; line++) {
document.insertString(document.getLineStartOffset(line), toInsert);
}
return;
}
// We've pasted text to the non-first column and exact white space between the line start and
// caret position on the moment of paste
// has been removed by formatter during 'adjust line indent'
// Example:
// copied text:
// ' line1
// line2'
// after paste:
// line start -> ' I line1
// line2' (I - caret position during 'paste')
// formatter removed white space between the line start and caret position, so, current
// document state is:
// ' line1
// line2'
if (anchorLine == firstLine && -diff == startOffset - firstLineStart) {
return;
}
if (anchorLine != firstLine || -diff > startOffset - firstLineStart) {
final int desiredSymbolsToRemove;
if (anchorLine == firstLine) {
desiredSymbolsToRemove = -diff - (startOffset - firstLineStart);
} else {
desiredSymbolsToRemove = -diff;
}
for (int line = anchorLine + 1; line <= lastLine; line++) {
int currentLineStart = document.getLineStartOffset(line);
int currentLineIndentOffset = CharArrayUtil.shiftForward(chars, currentLineStart, " \t");
int symbolsToRemove =
Math.min(currentLineIndentOffset - currentLineStart, desiredSymbolsToRemove);
if (symbolsToRemove > 0) {
document.deleteString(currentLineStart, currentLineStart + symbolsToRemove);
}
}
} else {
CharSequence toInsert = chars.subSequence(anchorLineStart, diff + startOffset);
for (int line = anchorLine + 1; line <= lastLine; line++) {
document.insertString(document.getLineStartOffset(line), toInsert);
}
}
}
@Override
@SuppressWarnings({"AssignmentToForLoopParameter"})
public void paint(
@NotNull Editor editor, @NotNull RangeHighlighter highlighter, @NotNull Graphics g) {
int startOffset = highlighter.getStartOffset();
final Document doc = highlighter.getDocument();
if (startOffset >= doc.getTextLength()) return;
final int endOffset = highlighter.getEndOffset();
final int endLine = doc.getLineNumber(endOffset);
int off;
int startLine = doc.getLineNumber(startOffset);
IndentGuideDescriptor descriptor =
editor.getIndentsModel().getDescriptor(startLine, endLine);
final CharSequence chars = doc.getCharsSequence();
do {
int start = doc.getLineStartOffset(startLine);
int end = doc.getLineEndOffset(startLine);
off = CharArrayUtil.shiftForward(chars, start, end, " \t");
startLine--;
} while (startLine > 1 && off < doc.getTextLength() && chars.charAt(off) == '\n');
final VisualPosition startPosition = editor.offsetToVisualPosition(off);
int indentColumn = startPosition.column;
// It's considered that indent guide can cross not only white space but comments, javadocs
// etc. Hence, there is a possible
// case that the first indent guide line is, say, single-line comment where comment
// symbols ('//') are located at the first
// visual column. We need to calculate correct indent guide column then.
int lineShift = 1;
if (indentColumn <= 0 && descriptor != null) {
indentColumn = descriptor.indentLevel;
lineShift = 0;
}
if (indentColumn <= 0) return;
final FoldingModel foldingModel = editor.getFoldingModel();
if (foldingModel.isOffsetCollapsed(off)) return;
final FoldRegion headerRegion =
foldingModel.getCollapsedRegionAtOffset(doc.getLineEndOffset(doc.getLineNumber(off)));
final FoldRegion tailRegion =
foldingModel.getCollapsedRegionAtOffset(
doc.getLineStartOffset(doc.getLineNumber(endOffset)));
if (tailRegion != null && tailRegion == headerRegion) return;
final boolean selected;
final IndentGuideDescriptor guide = editor.getIndentsModel().getCaretIndentGuide();
if (guide != null) {
final CaretModel caretModel = editor.getCaretModel();
final int caretOffset = caretModel.getOffset();
selected =
caretOffset >= off
&& caretOffset < endOffset
&& caretModel.getLogicalPosition().column == indentColumn;
} else {
selected = false;
}
Point start =
editor.visualPositionToXY(
new VisualPosition(startPosition.line + lineShift, indentColumn));
final VisualPosition endPosition = editor.offsetToVisualPosition(endOffset);
Point end =
editor.visualPositionToXY(new VisualPosition(endPosition.line, endPosition.column));
int maxY = end.y;
if (endPosition.line == editor.offsetToVisualPosition(doc.getTextLength()).line) {
maxY += editor.getLineHeight();
}
Rectangle clip = g.getClipBounds();
if (clip != null) {
if (clip.y >= maxY || clip.y + clip.height <= start.y) {
return;
}
maxY = Math.min(maxY, clip.y + clip.height);
}
final EditorColorsScheme scheme = editor.getColorsScheme();
g.setColor(
selected
? scheme.getColor(EditorColors.SELECTED_INDENT_GUIDE_COLOR)
: scheme.getColor(EditorColors.INDENT_GUIDE_COLOR));
// There is a possible case that indent line intersects soft wrap-introduced text.
// Example:
// this is a long line <soft-wrap>
// that| is soft-wrapped
// |
// | <- vertical indent
//
// Also it's possible that no additional intersections are added because of soft wrap:
// this is a long line <soft-wrap>
// | that is soft-wrapped
// |
// | <- vertical indent
// We want to use the following approach then:
// 1. Show only active indent if it crosses soft wrap-introduced text;
// 2. Show indent as is if it doesn't intersect with soft wrap-introduced text;
if (selected) {
g.drawLine(start.x + 2, start.y, start.x + 2, maxY);
} else {
int y = start.y;
int newY = start.y;
SoftWrapModel softWrapModel = editor.getSoftWrapModel();
int lineHeight = editor.getLineHeight();
for (int i = Math.max(0, startLine + lineShift); i < endLine && newY < maxY; i++) {
List<? extends SoftWrap> softWraps = softWrapModel.getSoftWrapsForLine(i);
int logicalLineHeight = softWraps.size() * lineHeight;
if (i > startLine + lineShift) {
logicalLineHeight +=
lineHeight; // We assume that initial 'y' value points just below the target
// line.
}
if (!softWraps.isEmpty() && softWraps.get(0).getIndentInColumns() < indentColumn) {
if (y < newY
|| i
> startLine
+ lineShift) { // There is a possible case that soft wrap is located on
// indent start line.
g.drawLine(start.x + 2, y, start.x + 2, newY + lineHeight);
}
newY += logicalLineHeight;
y = newY;
} else {
newY += logicalLineHeight;
}
FoldRegion foldRegion =
foldingModel.getCollapsedRegionAtOffset(doc.getLineEndOffset(i));
if (foldRegion != null && foldRegion.getEndOffset() < doc.getTextLength()) {
i = doc.getLineNumber(foldRegion.getEndOffset());
}
}
if (y < maxY) {
g.drawLine(start.x + 2, y, start.x + 2, maxY);
}
}
}
private static CompletionAssertions.WatchingInsertionContext insertItemHonorBlockSelection(
CompletionProgressIndicator indicator,
LookupElement item,
char completionChar,
List<LookupElement> items,
CompletionLookupArranger.StatisticsUpdate update) {
final Editor editor = indicator.getEditor();
final int caretOffset = editor.getCaretModel().getOffset();
int idEndOffset = indicator.getIdentifierEndOffset();
if (idEndOffset < 0) {
idEndOffset = CompletionInitializationContext.calcDefaultIdentifierEnd(editor, caretOffset);
}
CompletionAssertions.WatchingInsertionContext context = null;
if (editor.getSelectionModel().hasBlockSelection()
&& editor.getSelectionModel().getBlockSelectionEnds().length > 0) {
List<RangeMarker> insertionPoints = new ArrayList<RangeMarker>();
int idDelta = 0;
Document document = editor.getDocument();
int caretLine = document.getLineNumber(editor.getCaretModel().getOffset());
for (int point : editor.getSelectionModel().getBlockSelectionEnds()) {
insertionPoints.add(document.createRangeMarker(point, point));
if (document.getLineNumber(point) == document.getLineNumber(idEndOffset)) {
idDelta = idEndOffset - point;
}
}
List<RangeMarker> caretsAfter = new ArrayList<RangeMarker>();
for (RangeMarker marker : insertionPoints) {
if (marker.isValid()) {
int insertionPoint = marker.getStartOffset();
context =
insertItem(
indicator,
item,
completionChar,
items,
update,
editor,
insertionPoint,
idDelta + insertionPoint);
int offset = editor.getCaretModel().getOffset();
caretsAfter.add(document.createRangeMarker(offset, offset));
}
}
assert context != null;
restoreBlockSelection(editor, caretsAfter, caretLine);
for (RangeMarker insertionPoint : insertionPoints) {
insertionPoint.dispose();
}
for (RangeMarker marker : caretsAfter) {
marker.dispose();
}
} else {
context =
insertItem(
indicator, item, completionChar, items, update, editor, caretOffset, idEndOffset);
}
return context;
}