// ------------------------------
public void
scrollToCaret() { // not called - fixed with putting visible scrollbars on JScrollPane
//
Rectangle rect1 = scroller1.getViewport().getViewRect();
double x1 = rect1.getX();
double y1 = rect1.getY();
double r1height = rect1.getHeight();
double r1width = rect1.getWidth();
Caret caret1 = editor1.getCaret();
Point pt2 = caret1.getMagicCaretPosition(); // the end of the string
double x2 = pt2.getX();
double y2 = pt2.getY();
if (((x2 > x1) && (x2 < (x1 + r1width))) && ((y2 > y1) && (y2 < (y1 + r1height)))) {
// inview
} else {
double newheight = r1height / 2;
double newwidth = r1width / 2;
double x3 = pt2.getX() - newwidth;
double y3 = pt2.getY() - newheight;
if (x3 < 0) x3 = 0;
if (y3 < 0) y3 = 0;
Rectangle rect3 = new Rectangle((int) x3, (int) y3, (int) newwidth, (int) newheight);
editor1.scrollRectToVisible(rect3);
}
} // end scrollToCaret
static void updateStyle(JTextComponent comp, SynthContext context, String prefix) {
SynthStyle style = context.getStyle();
Color color = comp.getCaretColor();
if (color == null || color instanceof UIResource) {
comp.setCaretColor((Color) style.get(context, prefix + ".caretForeground"));
}
Color fg = comp.getForeground();
if (fg == null || fg instanceof UIResource) {
fg = style.getColorForState(context, ColorType.TEXT_FOREGROUND);
if (fg != null) {
comp.setForeground(fg);
}
}
Object ar = style.get(context, prefix + ".caretAspectRatio");
if (ar instanceof Number) {
comp.putClientProperty("caretAspectRatio", ar);
}
context.setComponentState(SELECTED | FOCUSED);
Color s = comp.getSelectionColor();
if (s == null || s instanceof UIResource) {
comp.setSelectionColor(style.getColor(context, ColorType.TEXT_BACKGROUND));
}
Color sfg = comp.getSelectedTextColor();
if (sfg == null || sfg instanceof UIResource) {
comp.setSelectedTextColor(style.getColor(context, ColorType.TEXT_FOREGROUND));
}
context.setComponentState(DISABLED);
Color dfg = comp.getDisabledTextColor();
if (dfg == null || dfg instanceof UIResource) {
comp.setDisabledTextColor(style.getColor(context, ColorType.TEXT_FOREGROUND));
}
Insets margin = comp.getMargin();
if (margin == null || margin instanceof UIResource) {
margin = (Insets) style.get(context, prefix + ".margin");
if (margin == null) {
// Some places assume margins are non-null.
margin = SynthLookAndFeel.EMPTY_UIRESOURCE_INSETS;
}
comp.setMargin(margin);
}
Caret caret = comp.getCaret();
if (caret instanceof UIResource) {
Object o = style.get(context, prefix + ".caretBlinkRate");
if (o != null && o instanceof Integer) {
Integer rate = (Integer) o;
caret.setBlinkRate(rate.intValue());
}
}
}
private void paintCaret(Graphics2D g_) {
EditorImpl.CaretRectangle[] locations = myEditor.getCaretLocations(true);
if (locations == null) return;
Graphics2D g = IdeBackgroundUtil.getOriginalGraphics(g_);
int lineHeight = myView.getLineHeight();
EditorSettings settings = myEditor.getSettings();
Color caretColor = myEditor.getColorsScheme().getColor(EditorColors.CARET_COLOR);
if (caretColor == null) caretColor = new JBColor(CARET_DARK, CARET_LIGHT);
g.setColor(caretColor);
for (EditorImpl.CaretRectangle location : locations) {
int x = location.myPoint.x;
int y = location.myPoint.y;
Caret caret = location.myCaret;
boolean isRtl = location.myIsRtl;
if (myEditor.isInsertMode() != settings.isBlockCursor()) {
int lineWidth = JBUI.scale(settings.getLineCursorWidth());
g.fillRect(x, y, lineWidth, lineHeight);
if (myDocument.getTextLength() > 0
&& caret != null
&& !myView.getLineLayout(caret.getLogicalPosition().line).isLtr()) {
g.fillPolygon(
new int[] {
isRtl ? x + lineWidth : x,
isRtl ? x + lineWidth - CARET_DIRECTION_MARK_SIZE : x + CARET_DIRECTION_MARK_SIZE,
isRtl ? x + lineWidth : x
},
new int[] {y, y, y + CARET_DIRECTION_MARK_SIZE},
3);
}
} else {
int width = location.myWidth;
int startX = Math.max(0, isRtl ? x - width : x);
g.fillRect(startX, y, width, lineHeight - 1);
if (myDocument.getTextLength() > 0 && caret != null) {
int targetVisualColumn = caret.getVisualPosition().column;
for (VisualLineFragmentsIterator.Fragment fragment :
VisualLineFragmentsIterator.create(myView, caret.getVisualLineStart(), false)) {
int startVisualColumn = fragment.getStartVisualColumn();
int endVisualColumn = fragment.getEndVisualColumn();
if (startVisualColumn < targetVisualColumn && endVisualColumn > targetVisualColumn
|| startVisualColumn == targetVisualColumn && !isRtl
|| endVisualColumn == targetVisualColumn && isRtl) {
g.setColor(ColorUtil.isDark(caretColor) ? CARET_LIGHT : CARET_DARK);
fragment.draw(
g,
startX,
y + myView.getAscent(),
targetVisualColumn - startVisualColumn - (isRtl ? 1 : 0),
targetVisualColumn - startVisualColumn + (isRtl ? 0 : 1));
break;
}
}
}
}
}
}
private void initializePane() {
mode = INSERT;
addKeyListener(
new KeyAdapter() {
public void keyPressed(KeyEvent e) {
if (e.getKeyCode() == KeyEvent.VK_INSERT) {
toggleTypingMode();
}
}
});
// all editors display another caret when in overwrite mode
// replace it
setFont(new Font("Monospaced", Font.PLAIN, 12));
Caret c =
new DefaultCaret() {
public void paint(Graphics g) {
if (mode == INSERT) {
super.paint(g);
return;
}
JTextComponent comp = getComponent();
int dot = getDot();
Rectangle r = null;
char c;
try {
r = comp.modelToView(dot);
if (r == null) return;
c = comp.getText(dot, 1).charAt(0);
} catch (BadLocationException e) {
return;
}
// erase provious caret
if ((x != r.x) || (y != r.y)) {
repaint();
x = r.x;
y = r.y;
height = r.height;
}
g.setColor(comp.getCaretColor());
g.setXORMode(comp.getBackground());
width = g.getFontMetrics().charWidth(c);
if (c == '\t' || c == '\n') width = g.getFontMetrics().charWidth(' ');
if (isVisible()) {
g.fillRect(r.x, r.y, width, r.height);
}
}
};
c.setBlinkRate(500); // default rate
setCaret(c);
}
/**
* Provides a way to determine the next visually represented model location at which one might
* place a caret. Some views may not be visible, they might not be in the same order found in the
* model, or they just might not allow access to some of the locations in the model.
*
* @param pos the position to convert >= 0
* @param a the allocated region in which to render
* @param direction the direction from the current position that can be thought of as the arrow
* keys typically found on a keyboard. This will be one of the following values:
* <ul>
* <li>SwingConstants.WEST
* <li>SwingConstants.EAST
* <li>SwingConstants.NORTH
* <li>SwingConstants.SOUTH
* </ul>
*
* @return the location within the model that best represents the next location visual position
* @exception BadLocationException
* @exception IllegalArgumentException if <code>direction</code> doesn't have one of the legal
* values above
*/
public int getNextVisualPositionFrom(
int pos, Position.Bias b, Shape a, int direction, Position.Bias[] biasRet)
throws BadLocationException {
biasRet[0] = Position.Bias.Forward;
switch (direction) {
case NORTH:
case SOUTH:
{
if (pos == -1) {
pos = (direction == NORTH) ? Math.max(0, getEndOffset() - 1) : getStartOffset();
break;
}
JTextComponent target = (JTextComponent) getContainer();
Caret c = (target != null) ? target.getCaret() : null;
// YECK! Ideally, the x location from the magic caret position
// would be passed in.
Point mcp;
if (c != null) {
mcp = c.getMagicCaretPosition();
} else {
mcp = null;
}
int x;
if (mcp == null) {
Rectangle loc = target.modelToView(pos);
x = (loc == null) ? 0 : loc.x;
} else {
x = mcp.x;
}
if (direction == NORTH) {
pos = Utilities.getPositionAbove(target, pos, x);
} else {
pos = Utilities.getPositionBelow(target, pos, x);
}
}
break;
case WEST:
if (pos == -1) {
pos = Math.max(0, getEndOffset() - 1);
} else {
pos = Math.max(0, pos - 1);
}
break;
case EAST:
if (pos == -1) {
pos = getStartOffset();
} else {
pos = Math.min(pos + 1, getDocument().getLength());
}
break;
default:
throw new IllegalArgumentException("Bad direction: " + direction);
}
return pos;
}
// HDC WINAPI BeginPaint( HWND hwnd, PAINTSTRUCT *lps )
public static int BeginPaint(int hwnd, int lps) {
WinWindow win = WinWindow.get(hwnd);
if (lps == 0) return 0;
Caret.HideCaret(hwnd);
int rgn = WinRegion.CreateRectRgn(0, 0, win.rectWindow.width(), win.rectWindow.height());
Message.SendMessageA(hwnd, WM_NCPAINT, rgn, 0);
GdiObj.DeleteObject(rgn);
WinDC dc = win.getDC();
if (win.invalidationRect == null) {
new WinRect(0, 0, win.rectClient.width(), win.rectClient.height()).write(lps + 8);
} else {
dc.clipX = win.invalidationRect.left;
dc.clipY = win.invalidationRect.top;
dc.clipCx = win.invalidationRect.width();
dc.clipCy = win.invalidationRect.height();
win.invalidationRect.write(lps + 8);
}
int hdc = dc.handle;
writed(lps, hdc);
writed(lps + 4, Message.SendMessageA(hwnd, WM_ERASEBKGND, hdc, 0));
return readd(lps);
}
Dimension getPreferredSize() {
int widthWithoutCaret = getPreferredWidth();
int width = widthWithoutCaret;
if (!myDocument.isInBulkUpdate()) {
for (Caret caret : myEditor.getCaretModel().getAllCarets()) {
if (caret.isUpToDate()) {
int caretX = myView.visualPositionToXY(caret.getVisualPosition()).x;
width = Math.max(caretX, width);
}
}
}
if (shouldRespectAdditionalColumns(widthWithoutCaret)) {
width += myEditor.getSettings().getAdditionalColumnsCount() * myView.getPlainSpaceWidth();
}
Insets insets = myView.getInsets();
return new Dimension(width + insets.left + insets.right, getPreferredHeight());
}
private Map<Integer, Couple<Integer>> createVirtualSelectionMap(
int startVisualLine, int endVisualLine) {
HashMap<Integer, Couple<Integer>> map = new HashMap<Integer, Couple<Integer>>();
for (Caret caret : myEditor.getCaretModel().getAllCarets()) {
if (caret.hasSelection()) {
VisualPosition selectionStart = caret.getSelectionStartPosition();
VisualPosition selectionEnd = caret.getSelectionEndPosition();
if (selectionStart.line == selectionEnd.line) {
int line = selectionStart.line;
if (line >= startVisualLine && line <= endVisualLine) {
map.put(line, Couple.of(selectionStart.column, selectionEnd.column));
}
}
}
}
return map;
}
// BOOL EndPaint(HWND hWnd, const PAINTSTRUCT *lpPaint)
public static int EndPaint(int hWnd, int lpPaint) {
WinDC dc = WinDC.get(readd(lpPaint));
if (dc != null) dc.close();
Caret.ShowCaret(hWnd);
Main.drawImage(StaticData.screen.getImage());
WinWindow.get(hWnd).validate();
return TRUE;
}
public void collapseFoldRegion(FoldRegion region) {
assertIsDispatchThreadForEditor();
if (!region.isExpanded()) return;
if (!myIsBatchFoldingProcessing) {
LOG.error("Fold regions must be collapsed or expanded inside batchFoldProcessing() only.");
}
List<Caret> carets = myEditor.getCaretModel().getAllCarets();
for (Caret caret : carets) {
LogicalPosition caretPosition = caret.getLogicalPosition();
int caretOffset = myEditor.logicalPositionToOffset(caretPosition);
if (FoldRegionsTree.contains(region, caretOffset)) {
if (myDoNotCollapseCaret) return;
}
}
for (Caret caret : carets) {
LogicalPosition caretPosition = caret.getLogicalPosition();
int caretOffset = myEditor.logicalPositionToOffset(caretPosition);
if (FoldRegionsTree.contains(region, caretOffset)) {
if (caret.getUserData(SAVED_CARET_POSITION) == null) {
caret.putUserData(SAVED_CARET_POSITION, caretPosition.withoutVisualPositionInfo());
}
}
}
myFoldRegionsProcessed = true;
((FoldRegionImpl) region).setExpandedInternal(false);
notifyListenersOnFoldRegionStateChange(region);
}
public void actionPerformed(JTextComponent text) {
indentationLogic = ((EditorPane) text).getIndentationLogic();
StyledDocument doc = (StyledDocument) text.getDocument();
Element map = doc.getDefaultRootElement();
Caret c = text.getCaret();
int dot = c.getDot();
int mark = c.getMark();
int line1 = map.getElementIndex(dot);
if (dot != mark) {
int line2 = map.getElementIndex(mark);
int begin = Math.min(line1, line2);
int end = Math.max(line1, line2);
Element elem;
try {
for (line1 = begin; line1 < end; line1++) {
elem = map.getElement(line1);
handleDecreaseIndent(line1, elem, doc);
}
elem = map.getElement(end);
int start = elem.getStartOffset();
if (Math.max(c.getDot(), c.getMark()) != start) {
handleDecreaseIndent(end, elem, doc);
}
} catch (BadLocationException ble) {
Debug.error(me + "Problem while de-indenting line\n%s", ble.getMessage());
UIManager.getLookAndFeel().provideErrorFeedback(text);
}
} else {
Element elem = map.getElement(line1);
try {
handleDecreaseIndent(line1, elem, doc);
} catch (BadLocationException ble) {
Debug.error(me + "Problem while de-indenting line\n%s", ble.getMessage());
UIManager.getLookAndFeel().provideErrorFeedback(text);
}
}
}
public void actionPerformed(JTextComponent text) {
indentationLogic = ((EditorPane) text).getIndentationLogic();
boolean indentError = false;
Document doc = text.getDocument();
Element map = doc.getDefaultRootElement();
String tabWhitespace = PreferencesUser.getInstance().getTabWhitespace();
Caret c = text.getCaret();
int dot = c.getDot();
int mark = c.getMark();
int dotLine = map.getElementIndex(dot);
int markLine = map.getElementIndex(mark);
if (dotLine != markLine) {
int first = Math.min(dotLine, markLine);
int last = Math.max(dotLine, markLine);
Element elem;
int start;
try {
for (int i = first; i < last; i++) {
elem = map.getElement(i);
start = elem.getStartOffset();
doc.insertString(start, tabWhitespace, null);
}
elem = map.getElement(last);
start = elem.getStartOffset();
if (Math.max(c.getDot(), c.getMark()) != start) {
doc.insertString(start, tabWhitespace, null);
}
} catch (BadLocationException ble) {
Debug.error(me + "Problem while indenting line\n%s", ble.getMessage());
UIManager.getLookAndFeel().provideErrorFeedback(text);
}
} else {
text.replaceSelection(tabWhitespace);
}
}
public void expandFoldRegion(FoldRegion region) {
assertIsDispatchThreadForEditor();
if (region.isExpanded() || region.shouldNeverExpand()) return;
if (!myIsBatchFoldingProcessing) {
LOG.error("Fold regions must be collapsed or expanded inside batchFoldProcessing() only.");
}
for (Caret caret : myEditor.getCaretModel().getAllCarets()) {
LogicalPosition savedPosition = caret.getUserData(SAVED_CARET_POSITION);
if (savedPosition != null) {
int savedOffset = myEditor.logicalPositionToOffset(savedPosition);
FoldRegion[] allCollapsed = myFoldTree.fetchCollapsedAt(savedOffset);
if (allCollapsed.length == 1 && allCollapsed[0] == region) {
caret.moveToLogicalPosition(savedPosition);
}
}
}
myFoldRegionsProcessed = true;
((FoldRegionImpl) region).setExpandedInternal(true);
notifyListenersOnFoldRegionStateChange(region);
}
public void setCaretPosition(int position) {
Caret c = textView.getCaret();
// move the caret
c.setDot(position);
}
public int getCaretPosition() {
Caret c = textView.getCaret();
return c.getDot();
}
public void flushCaretPosition() {
for (Caret caret : myEditor.getCaretModel().getAllCarets()) {
caret.putUserData(SAVED_CARET_POSITION, null);
}
}
private void notifyBatchFoldingProcessingDone(final boolean moveCaretFromCollapsedRegion) {
rebuild();
for (FoldingListener listener : myListeners) {
listener.onFoldProcessingEnd();
}
myEditor.updateCaretCursor();
myEditor.recalculateSizeAndRepaint();
myEditor.getGutterComponentEx().updateSize();
myEditor.getGutterComponentEx().repaint();
for (Caret caret : myEditor.getCaretModel().getAllCarets()) {
// There is a possible case that caret position is already visual position aware. But visual
// position depends on number of folded
// logical lines as well, hence, we can't be sure that target logical position defines correct
// visual position because fold
// regions have just changed. Hence, we use 'raw' logical position instead.
LogicalPosition caretPosition = caret.getLogicalPosition().withoutVisualPositionInfo();
int caretOffset = myEditor.logicalPositionToOffset(caretPosition);
int selectionStart = caret.getSelectionStart();
int selectionEnd = caret.getSelectionEnd();
LogicalPosition positionToUse = null;
int offsetToUse = -1;
FoldRegion collapsed = myFoldTree.fetchOutermost(caretOffset);
LogicalPosition savedPosition = caret.getUserData(SAVED_CARET_POSITION);
if (savedPosition != null) {
int savedOffset = myEditor.logicalPositionToOffset(savedPosition);
FoldRegion collapsedAtSaved = myFoldTree.fetchOutermost(savedOffset);
if (collapsedAtSaved == null) {
positionToUse = savedPosition;
} else {
offsetToUse = collapsedAtSaved.getStartOffset();
}
}
if (collapsed != null && positionToUse == null) {
positionToUse = myEditor.offsetToLogicalPosition(collapsed.getStartOffset());
}
if (moveCaretFromCollapsedRegion && caret.isUpToDate()) {
if (offsetToUse >= 0) {
caret.moveToOffset(offsetToUse);
} else if (positionToUse != null) {
caret.moveToLogicalPosition(positionToUse);
} else {
caret.moveToLogicalPosition(caretPosition);
}
}
caret.putUserData(SAVED_CARET_POSITION, savedPosition);
if (isOffsetInsideCollapsedRegion(selectionStart)
|| isOffsetInsideCollapsedRegion(selectionEnd)) {
caret.removeSelection();
} else if (selectionStart < myEditor.getDocument().getTextLength()) {
caret.setSelection(selectionStart, selectionEnd);
}
}
if (mySavedCaretShift > 0) {
final ScrollingModel scrollingModel = myEditor.getScrollingModel();
scrollingModel.disableAnimation();
scrollingModel.scrollVertically(
myEditor.visibleLineToY(myEditor.getCaretModel().getVisualPosition().line)
- mySavedCaretShift);
scrollingModel.enableAnimation();
}
}
@Nullable
@Override
public TextBlockTransferableData collectTransferableData(
PsiFile file, Editor editor, int[] startOffsets, int[] endOffsets) {
if (!Registry.is("editor.richcopy.enable")) {
return null;
}
try {
for (TextWithMarkupBuilder builder : myBuilders) {
builder.reset();
}
SelectionModel selectionModel = editor.getSelectionModel();
if (selectionModel.hasBlockSelection()) {
return null; // unsupported legacy mode
}
RichCopySettings settings = RichCopySettings.getInstance();
List<Caret> carets = editor.getCaretModel().getAllCarets();
Caret firstCaret = carets.get(0);
final int indentSymbolsToStrip;
final int firstLineStartOffset;
if (settings.isStripIndents() && carets.size() == 1) {
Pair<Integer, Integer> p =
calcIndentSymbolsToStrip(
editor.getDocument(), firstCaret.getSelectionStart(), firstCaret.getSelectionEnd());
firstLineStartOffset = p.first;
indentSymbolsToStrip = p.second;
} else {
firstLineStartOffset = firstCaret.getSelectionStart();
indentSymbolsToStrip = 0;
}
logInitial(editor, startOffsets, endOffsets, indentSymbolsToStrip, firstLineStartOffset);
CharSequence text = editor.getDocument().getCharsSequence();
EditorColorsScheme schemeToUse = settings.getColorsScheme(editor.getColorsScheme());
EditorHighlighter highlighter =
HighlighterFactory.createHighlighter(
file.getVirtualFile(), schemeToUse, file.getProject());
highlighter.setText(text);
MarkupModel markupModel =
DocumentMarkupModel.forDocument(editor.getDocument(), file.getProject(), false);
Context context = new Context(text, schemeToUse, indentSymbolsToStrip);
int shift = 0;
int endOffset = 0;
Caret prevCaret = null;
for (Caret caret : carets) {
int caretSelectionStart = caret.getSelectionStart();
int caretSelectionEnd = caret.getSelectionEnd();
int startOffsetToUse;
if (caret == firstCaret) {
startOffsetToUse = firstLineStartOffset;
} else {
startOffsetToUse = caretSelectionStart;
assert prevCaret != null;
String prevCaretSelectedText = prevCaret.getSelectedText();
// Block selection fills short lines by white spaces.
int fillStringLength =
prevCaretSelectedText == null
? 0
: prevCaretSelectedText.length()
- (prevCaret.getSelectionEnd() - prevCaret.getSelectionStart());
int endLineOffset = endOffset + shift + fillStringLength;
context.builder.addText(endLineOffset, endLineOffset + 1);
shift++; // Block selection ends '\n' at line end
shift += fillStringLength;
}
shift += endOffset - caretSelectionStart;
endOffset = caretSelectionEnd;
context.reset(shift);
prevCaret = caret;
if (endOffset <= startOffsetToUse) {
continue;
}
MarkupIterator markupIterator =
new MarkupIterator(
text,
new CompositeRangeIterator(
schemeToUse,
new HighlighterRangeIterator(highlighter, startOffsetToUse, endOffset),
new MarkupModelRangeIterator(
markupModel, schemeToUse, startOffsetToUse, endOffset)),
schemeToUse);
try {
context.iterate(markupIterator, endOffset);
} finally {
markupIterator.dispose();
}
}
SyntaxInfo syntaxInfo = context.finish();
logSyntaxInfo(syntaxInfo);
for (TextWithMarkupBuilder builder : myBuilders) {
builder.build(syntaxInfo);
}
} catch (Exception e) {
// catching the exception so that the rest of copy/paste functionality can still work fine
LOG.error(e);
}
return null;
}
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());
}
}
}
@Override
public void actionPerformed(ActionEvent e) {
JTextComponent textArea = (JTextComponent) e.getSource();
Caret caret = textArea.getCaret();
int dot = caret.getDot();
/*
* Move to the beginning/end of selection on a "non-shifted"
* left- or right-keypress. We shouldn't have to worry about
* navigation filters as, if one is being used, it let us get
* to that position before.
*/
if (!select) {
switch (direction) {
case SwingConstants.EAST:
int mark = caret.getMark();
if (dot != mark) {
caret.setDot(Math.max(dot, mark));
return;
}
break;
case SwingConstants.WEST:
mark = caret.getMark();
if (dot != mark) {
caret.setDot(Math.min(dot, mark));
return;
}
break;
default:
}
}
Position.Bias[] bias = new Position.Bias[1];
Point magicPosition = caret.getMagicCaretPosition();
try {
if (magicPosition == null
&& (direction == SwingConstants.NORTH || direction == SwingConstants.SOUTH)) {
Rectangle r = textArea.modelToView(dot);
magicPosition = new Point(r.x, r.y);
}
NavigationFilter filter = textArea.getNavigationFilter();
if (filter != null) {
dot =
filter.getNextVisualPositionFrom(
textArea, dot, Position.Bias.Forward, direction, bias);
} else {
if (direction == SwingConstants.NORTH || direction == SwingConstants.SOUTH) {
dot = getNSVisualPosition((EditorPane) textArea, dot, direction);
} else {
dot =
textArea
.getUI()
.getNextVisualPositionFrom(
textArea, dot, Position.Bias.Forward, direction, bias);
}
}
if (select) {
caret.moveDot(dot);
} else {
caret.setDot(dot);
}
if (magicPosition != null
&& (direction == SwingConstants.NORTH || direction == SwingConstants.SOUTH)) {
caret.setMagicCaretPosition(magicPosition);
}
} catch (BadLocationException ble) {
Debug.error(me + "Problem while trying to move caret\n%s", ble.getMessage());
}
}