private BeforeAfter<Integer> getEditorLines() {
final Editor editor = ((DiffPanelImpl) getCurrentPanel()).getEditor1();
Rectangle visibleArea = editor.getScrollingModel().getVisibleArea();
final int offset = editor.getScrollingModel().getVerticalScrollOffset();
int leftPixels = offset % editor.getLineHeight();
final Point start = visibleArea.getLocation();
final LogicalPosition startLp = editor.xyToLogicalPosition(start);
final Point location = new Point(start.x + visibleArea.width, start.y + visibleArea.height);
final LogicalPosition lp = editor.xyToLogicalPosition(location);
int curStartLine =
startLp.line == (editor.getDocument().getLineCount() - 1)
? startLp.line
: (startLp.line + 1);
int cutEndLine = lp.line == 0 ? 0 : lp.line - 1;
boolean commonPartOk = leftPixels == 0 || startLp.line == lp.line;
return new BeforeAfter<Integer>(
commonPartOk && startLp.softWrapLinesOnCurrentLogicalLine == 0
? startLp.line
: curStartLine,
commonPartOk && lp.softWrapLinesOnCurrentLogicalLine == 0 ? lp.line : cutEndLine);
/*if (leftPixels == 0 || startLp.line == lp.line) {
return new BeforeAfter<Integer>(startLp.line, lp.line);
} else {
return new BeforeAfter<Integer>(curStartLine, cutEndLine);
}*/
}
private void recalculateMaxValues() {
myIdxLeft = widestEditor(myLeftEditors);
final Editor leftEditor = myLeftEditors.get(myIdxLeft);
final int wholeWidth = leftEditor.getContentComponent().getWidth();
final Rectangle va = leftEditor.getScrollingModel().getVisibleArea();
final int visibleLeft = leftEditor.xyToVisualPosition(new Point(va.width, 0)).column;
myMaxColumnsLeft = (int) (visibleLeft * ((double) wholeWidth / va.getWidth()));
myIdxRight = widestEditor(myRightEditors);
final Editor rightEditor = myRightEditors.get(myIdxRight);
final int wholeWidthRight = rightEditor.getContentComponent().getWidth();
final Rectangle vaRight = rightEditor.getScrollingModel().getVisibleArea();
final int visibleRight = rightEditor.xyToVisualPosition(new Point(va.width, 0)).column;
myMaxColumnsRight = (int) (visibleRight * ((double) wholeWidthRight / vaRight.getWidth()));
myByLeft = !(myMaxColumnsLeft <= visibleLeft);
if (!myByLeft) {
// check right editor
if (myLeftScroll.getVisibleAmount() != visibleRight) {
myLeftScroll.setVisibleAmount(visibleRight);
}
myLeftScroll.setMaximum(myMaxColumnsRight);
} else {
if (myLeftScroll.getVisibleAmount() != visibleLeft) {
myLeftScroll.setVisibleAmount(visibleLeft);
}
myLeftScroll.setMaximum(myMaxColumnsLeft);
}
}
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 void removeFromEditor() {
Editor editor = mySearchResults.getEditor();
if (myReplacementBalloon != null) {
myReplacementBalloon.hide();
}
if (editor != null) {
for (VisibleAreaListener visibleAreaListener : myVisibleAreaListenersToRemove) {
editor.getScrollingModel().removeVisibleAreaListener(visibleAreaListener);
}
myVisibleAreaListenersToRemove.clear();
Project project = mySearchResults.getProject();
if (project != null && !project.isDisposed()) {
for (RangeHighlighter h : myHighlighters) {
HighlightManager.getInstance(project).removeSegmentHighlighter(editor, h);
}
if (myCursorHighlighter != null) {
HighlightManager.getInstance(project)
.removeSegmentHighlighter(editor, myCursorHighlighter);
myCursorHighlighter = null;
}
}
myHighlighters.clear();
if (myListeningSelection) {
editor.getSelectionModel().removeSelectionListener(this);
myListeningSelection = false;
}
}
}
public void startTemplateWithPrefix(
final Editor editor,
final TemplateImpl template,
final int templateStart,
@Nullable final PairProcessor<String, String> processor,
@Nullable final String argument) {
final int caretOffset = editor.getCaretModel().getOffset();
final TemplateState templateState = initTemplateState(editor);
CommandProcessor commandProcessor = CommandProcessor.getInstance();
commandProcessor.executeCommand(
myProject,
() -> {
editor.getDocument().deleteString(templateStart, caretOffset);
editor.getCaretModel().moveToOffset(templateStart);
editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
editor.getSelectionModel().removeSelection();
Map<String, String> predefinedVarValues = null;
if (argument != null) {
predefinedVarValues = new HashMap<String, String>();
predefinedVarValues.put(TemplateImpl.ARG, argument);
}
templateState.start(template, processor, predefinedVarValues);
},
CodeInsightBundle.message("insert.code.template.command"),
null);
}
public void nextPanel(final BeforeAfter<ShiftedSimpleContent> diff, final DiffPanel diffPanel) {
final Editor editor1 = ((DiffPanelImpl) diffPanel).getEditor1();
myLeftModels.add(editor1.getScrollingModel());
final Editor editor2 = ((DiffPanelImpl) diffPanel).getEditor2();
myRightModels.add(editor2.getScrollingModel());
if (myEditor == null) {
myEditor = editor1;
}
myLeftEditors.add(editor1);
myRightEditors.add(editor2);
((EditorEx) editor1).setHorizontalScrollbarVisible(false);
((EditorEx) editor1).setVerticalScrollbarVisible(false);
((EditorEx) editor1).getScrollPane().setWheelScrollingEnabled(false);
((EditorEx) editor2).setHorizontalScrollbarVisible(false);
((EditorEx) editor2).setVerticalScrollbarVisible(false);
((EditorEx) editor2).getScrollPane().setWheelScrollingEnabled(false);
}
@Override
public RelativePoint recalculateLocation(final Balloon object) {
FindResult cursor = mySearchResults.getCursor();
if (cursor == null) return null;
final TextRange cur = cursor;
int startOffset = cur.getStartOffset();
int endOffset = cur.getEndOffset();
if (startOffset >= myEditor.getDocument().getTextLength()) {
if (!object.isDisposed()) {
requestBalloonHiding(object);
}
return null;
}
if (!SearchResults.insideVisibleArea(myEditor, cur)) {
requestBalloonHiding(object);
VisibleAreaListener visibleAreaListener =
new VisibleAreaListener() {
@Override
public void visibleAreaChanged(VisibleAreaEvent e) {
if (SearchResults.insideVisibleArea(myEditor, cur)) {
showReplacementPreview();
final VisibleAreaListener visibleAreaListener = this;
final boolean remove = myVisibleAreaListenersToRemove.remove(visibleAreaListener);
if (remove) {
myEditor.getScrollingModel().removeVisibleAreaListener(visibleAreaListener);
}
}
}
};
myEditor.getScrollingModel().addVisibleAreaListener(visibleAreaListener);
myVisibleAreaListenersToRemove.add(visibleAreaListener);
}
Point startPoint = myEditor.visualPositionToXY(myEditor.offsetToVisualPosition(startOffset));
Point endPoint = myEditor.visualPositionToXY(myEditor.offsetToVisualPosition(endOffset));
Point point = new Point((startPoint.x + endPoint.x) / 2, startPoint.y);
return new RelativePoint(myEditor.getContentComponent(), point);
}
public void add(final Splitter splitter, final Editor editor) {
editor
.getScrollingModel()
.addVisibleAreaListener(new MyVisibleAreaListener(mySplitters.size()));
mySplitters.add(splitter);
}
