path: root/platform/platform-impl/src/com/intellij/openapi/editor/impl/CaretImpl.java

/*
 * Copyright 2000-2014 JetBrains s.r.o.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.intellij.openapi.editor.impl;

import com.intellij.diagnostic.LogMessageEx;
import com.intellij.openapi.actionSystem.IdeActions;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.editor.*;
import com.intellij.openapi.editor.actionSystem.EditorActionHandler;
import com.intellij.openapi.editor.actionSystem.EditorActionManager;
import com.intellij.openapi.editor.actions.EditorActionUtil;
import com.intellij.openapi.editor.event.CaretEvent;
import com.intellij.openapi.editor.event.DocumentEvent;
import com.intellij.openapi.editor.ex.DocumentEx;
import com.intellij.openapi.editor.ex.EditorGutterComponentEx;
import com.intellij.openapi.editor.ex.FoldingModelEx;
import com.intellij.openapi.editor.ex.util.EditorUtil;
import com.intellij.openapi.editor.impl.event.DocumentEventImpl;
import com.intellij.openapi.editor.impl.softwrap.SoftWrapHelper;
import com.intellij.openapi.ide.CopyPasteManager;
import com.intellij.openapi.util.Disposer;
import com.intellij.openapi.util.UserDataHolderBase;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.util.diff.FilesTooBigForDiffException;
import com.intellij.util.text.CharArrayUtil;
import com.intellij.util.ui.EmptyClipboardOwner;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.awt.*;
import java.awt.datatransfer.Clipboard;
import java.awt.datatransfer.StringSelection;
import java.util.List;

public class CaretImpl extends UserDataHolderBase implements Caret {
  private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.editor.impl.CaretImpl");

  private final EditorImpl myEditor;
  private boolean isValid = true;

  private LogicalPosition myLogicalCaret;
  private VerticalInfo myCaretInfo;
  private VisualPosition myVisibleCaret;
  private int myOffset;
  private int myVirtualSpaceOffset;
  private int myVisualLineStart;
  private int myVisualLineEnd;
  private RangeMarker savedBeforeBulkCaretMarker;
  private boolean mySkipChangeRequests;
  /**
   * Initial horizontal caret position during vertical navigation.
   * Similar to {@link #myDesiredX}, but represents logical caret position (<code>getLogicalPosition().column</code>) rather than visual.
   */
  private int myLastColumnNumber = 0;
  private int myDesiredSelectionStartColumn = -1;
  private int myDesiredSelectionEndColumn = -1;
  /**
   * We check that caret is located at the target offset at the end of {@link #moveToOffset(int, boolean)} method. However,
   * it's possible that the following situation occurs:
   * <p/>
   * <pre>
   * <ol>
   *   <li>Some client subscribes to caret change events;</li>
   *   <li>{@link #moveToLogicalPosition(LogicalPosition)} is called;</li>
   *   <li>Caret position is changed during {@link #moveToLogicalPosition(LogicalPosition)} processing;</li>
   *   <li>The client receives caret position change event and adjusts the position;</li>
   *   <li>{@link #moveToLogicalPosition(LogicalPosition)} processing is finished;</li>
   *   <li>{@link #moveToLogicalPosition(LogicalPosition)} reports an error because the caret is not located at the target offset;</li>
   * </ol>
   * </pre>
   * <p/>
   * This field serves as a flag that reports unexpected caret position change requests nested from {@link #moveToOffset(int, boolean)}.
   */
  private boolean myReportCaretMoves;
  /**
   * This field holds initial horizontal caret position during vertical navigation. It's used to determine target position when
   * moving to the new line. It is stored in pixels, not in columns, to account for non-monospaced fonts as well.
   * <p/>
   * Negative value means no coordinate should be preserved.
   */
  private int myDesiredX = -1;

  private volatile MyRangeMarker mySelectionMarker;
  private int startBefore;
  private int endBefore;
  boolean myUnknownDirection;
  // offsets of selection start/end position relative to end of line - can be non-zero in column selection mode
  // these are non-negative values, myStartVirtualOffset is always less or equal to myEndVirtualOffset
  private int myStartVirtualOffset;
  private int myEndVirtualOffset;

  CaretImpl(EditorImpl editor) {
    myEditor = editor;

    myLogicalCaret = new LogicalPosition(0, 0);
    myVisibleCaret = new VisualPosition(0, 0);
    myCaretInfo = new VerticalInfo(0, 0);
    myOffset = 0;
    myVisualLineStart = 0;
    Document doc = myEditor.getDocument();
    myVisualLineEnd = doc.getLineCount() > 1 ? doc.getLineStartOffset(1) : doc.getLineCount() == 0 ? 0 : doc.getLineEndOffset(0);
  }

  void onBulkDocumentUpdateStarted(@NotNull Document doc) {
    if (doc != myEditor.getDocument() || myOffset > doc.getTextLength() || savedBeforeBulkCaretMarker != null) return;
    savedBeforeBulkCaretMarker = doc.createRangeMarker(myOffset, myOffset);
  }

  void onBulkDocumentUpdateFinished(@NotNull Document doc) {
    if (doc != myEditor.getDocument() || myEditor.getCaretModel().myIsInUpdate) return;
    LOG.assertTrue(!myReportCaretMoves);

    if (savedBeforeBulkCaretMarker != null) {
      if(savedBeforeBulkCaretMarker.isValid()) {
        if(savedBeforeBulkCaretMarker.getStartOffset() != myOffset) {
          moveToOffset(savedBeforeBulkCaretMarker.getStartOffset());
        }
      } else if (myOffset > doc.getTextLength()) {
        moveToOffset(doc.getTextLength());
      }
      releaseBulkCaretMarker();
    }
  }

  public void beforeDocumentChange() {
    MyRangeMarker marker = mySelectionMarker;
    if (marker != null && marker.isValid()) {
      startBefore = marker.getStartOffset();
      endBefore = marker.getEndOffset();
    }
  }

  public void documentChanged() {
    MyRangeMarker marker = mySelectionMarker;
    if (marker != null) {
      int endAfter;
      int startAfter;
      if (marker.isValid()) {
        startAfter = marker.getStartOffset();
        endAfter = marker.getEndOffset();
        if (myEndVirtualOffset > 0 && (!isVirtualSelectionEnabled()
                                       || !EditorUtil.isAtLineEnd(myEditor, endAfter)
                                       || myEditor.getDocument().getLineNumber(startAfter) != myEditor.getDocument().getLineNumber(endAfter))) {
          myStartVirtualOffset = 0;
          myEndVirtualOffset = 0;
        }
      }
      else {
        startAfter = endAfter = getOffset();
        marker.release();
        myStartVirtualOffset = 0;
        myEndVirtualOffset = 0;
        mySelectionMarker = null;
      }

      if (startBefore != startAfter || endBefore != endAfter) {
        myEditor.getSelectionModel().fireSelectionChanged(startBefore, endBefore, startAfter, endAfter);
      }
    }
  }

  @Override
  public void moveToOffset(int offset) {
    moveToOffset(offset, false);
  }

  @Override
  public void moveToOffset(final int offset, final boolean locateBeforeSoftWrap) {
    assertIsDispatchThread();
    validateCallContext();
    if (mySkipChangeRequests) {
      return;
    }
    myEditor.getCaretModel().doWithCaretMerging(new Runnable() {
      public void run() {
        final LogicalPosition logicalPosition = myEditor.offsetToLogicalPosition(offset);
        CaretEvent event = moveToLogicalPosition(logicalPosition, locateBeforeSoftWrap, null, false);
        final LogicalPosition positionByOffsetAfterMove = myEditor.offsetToLogicalPosition(myOffset);
        if (!positionByOffsetAfterMove.equals(logicalPosition)) {
          StringBuilder debugBuffer = new StringBuilder();
          moveToLogicalPosition(logicalPosition, locateBeforeSoftWrap, debugBuffer, true);
          int textStart = Math.max(0, Math.min(offset, myOffset) - 1);
          final DocumentEx document = myEditor.getDocument();
          int textEnd = Math.min(document.getTextLength() - 1, Math.max(offset, myOffset) + 1);
          CharSequence text = document.getCharsSequence().subSequence(textStart, textEnd);
          StringBuilder positionToOffsetTrace = new StringBuilder();
          int inverseOffset = myEditor.logicalPositionToOffset(logicalPosition, positionToOffsetTrace);
          LogMessageEx.error(
            LOG, "caret moved to wrong offset. Please submit a dedicated ticket and attach current editor's text to it.",
            String.format(
              "Requested: offset=%d, logical position='%s' but actual: offset=%d, logical position='%s' (%s). %s%n"
              + "interested text [%d;%d): '%s'%n debug trace: %s%nLogical position -> offset ('%s'->'%d') trace: %s",
              offset, logicalPosition, myOffset, myLogicalCaret, positionByOffsetAfterMove, myEditor.dumpState(),
              textStart, textEnd, text, debugBuffer, logicalPosition, inverseOffset, positionToOffsetTrace
            )
          );
        }
        if (event != null) {
          myEditor.getCaretModel().fireCaretPositionChanged(event);
          EditorActionUtil.selectNonexpandableFold(myEditor);
        }
      }
    });
  }

  @NotNull
  @Override
  public CaretModel getCaretModel() {
    return myEditor.getCaretModel();
  }

  @Override
  public boolean isValid() {
    return isValid;
  }

  @Override
  public void moveCaretRelatively(int columnShift, int lineShift, boolean withSelection, boolean scrollToCaret) {
    moveCaretRelatively(columnShift, lineShift, withSelection, false, scrollToCaret);
  }

  void moveCaretRelatively(final int columnShift,
                                  final int lineShift,
                                  final boolean withSelection,
                                  final boolean blockSelection,
                                  final boolean scrollToCaret) {
    assertIsDispatchThread();
    if (mySkipChangeRequests) {
      return;
    }
    if (myReportCaretMoves) {
      LogMessageEx.error(LOG, "Unexpected caret move request");
    }
    if (!myEditor.isStickySelection() && !myEditor.getCaretModel().isDocumentChanged) {
      CopyPasteManager.getInstance().stopKillRings();
    }
    myEditor.getCaretModel().doWithCaretMerging(new Runnable() {
      public void run() {
        SelectionModelImpl selectionModel = myEditor.getSelectionModel();
        final int leadSelectionOffset = getLeadSelectionOffset();
        final VisualPosition leadSelectionPosition = getLeadSelectionPosition();
        LogicalPosition blockSelectionStart = selectionModel.hasBlockSelection()
                                              ? selectionModel.getBlockStart()
                                              : getLogicalPosition();
        EditorSettings editorSettings = myEditor.getSettings();
        VisualPosition visualCaret = getVisualPosition();

        int lastColumnNumber = myLastColumnNumber;
        int desiredX = myDesiredX;
        if (columnShift == 0) {
          if (myDesiredX < 0) {
            desiredX = getCurrentX();
          }
        }
        else {
          myDesiredX = desiredX = -1;
        }

        int newLineNumber = visualCaret.line + lineShift;
        int newColumnNumber = visualCaret.column + columnShift;
        if (desiredX >= 0) {
          newColumnNumber = myEditor.xyToVisualPosition(new Point(desiredX, Math.max(0, newLineNumber) * myEditor.getLineHeight())).column;
        }

        Document document = myEditor.getDocument();
        if (!editorSettings.isVirtualSpace() && lineShift == 0 && columnShift == 1) {
          int lastLine = document.getLineCount() - 1;
          if (lastLine < 0) lastLine = 0;
          if (EditorModificationUtil.calcAfterLineEnd(myEditor) >= 0 &&
              newLineNumber < myEditor.logicalToVisualPosition(new LogicalPosition(lastLine, 0)).line) {
            newColumnNumber = 0;
            newLineNumber++;
          }
        }
        else if (!editorSettings.isVirtualSpace() && lineShift == 0 && columnShift == -1) {
          if (newColumnNumber < 0 && newLineNumber > 0) {
            newLineNumber--;
            newColumnNumber = EditorUtil.getLastVisualLineColumnNumber(myEditor, newLineNumber);
          }
        }

        if (newColumnNumber < 0) newColumnNumber = 0;

        // There is a possible case that caret is located at the first line and user presses 'Shift+Up'. We want to select all text
        // from the document start to the current caret position then. So, we have a dedicated flag for tracking that.
        boolean selectToDocumentStart = false;
        if (newLineNumber < 0) {
          selectToDocumentStart = true;
          newLineNumber = 0;

          // We want to move caret to the first column if it's already located at the first line and 'Up' is pressed.
          newColumnNumber = 0;
          desiredX = -1;
          lastColumnNumber = -1;
        }

        VisualPosition pos = new VisualPosition(newLineNumber, newColumnNumber);
        if (!myEditor.getSoftWrapModel().isInsideSoftWrap(pos)) {
          LogicalPosition log = myEditor.visualToLogicalPosition(new VisualPosition(newLineNumber, newColumnNumber));
          int offset = myEditor.logicalPositionToOffset(log);
          if (offset >= document.getTextLength()) {
            int lastOffsetColumn = myEditor.offsetToVisualPosition(document.getTextLength()).column;
            // We want to move caret to the last column if if it's located at the last line and 'Down' is pressed.
            if (lastOffsetColumn > newColumnNumber) {
              newColumnNumber = lastOffsetColumn;
              desiredX = -1;
              lastColumnNumber = -1;
            }
          }
          if (!editorSettings.isCaretInsideTabs()) {
            CharSequence text = document.getCharsSequence();
            if (offset >= 0 && offset < document.getTextLength()) {
              if (text.charAt(offset) == '\t' && (columnShift <= 0 || offset == myOffset)) {
                if (columnShift <= 0) {
                  newColumnNumber = myEditor.offsetToVisualPosition(offset).column;
                }
                else {
                  SoftWrap softWrap = myEditor.getSoftWrapModel().getSoftWrap(offset + 1);
                  // There is a possible case that tabulation symbol is the last document symbol represented on a visual line before
                  // soft wrap. We can't just use column from 'offset + 1' because it would point on a next visual line.
                  if (softWrap == null) {
                    newColumnNumber = myEditor.offsetToVisualPosition(offset + 1).column;
                  }
                  else {
                    newColumnNumber = EditorUtil.getLastVisualLineColumnNumber(myEditor, newLineNumber);
                  }
                }
              }
            }
          }
        }

        pos = new VisualPosition(newLineNumber, newColumnNumber);
        if (columnShift != 0 && lineShift == 0 && myEditor.getSoftWrapModel().isInsideSoftWrap(pos)) {
          LogicalPosition logical = myEditor.visualToLogicalPosition(pos);
          int softWrapOffset = myEditor.logicalPositionToOffset(logical);
          if (columnShift >= 0) {
            moveToOffset(softWrapOffset);
          }
          else {
            int line = myEditor.offsetToVisualLine(softWrapOffset - 1);
            moveToVisualPosition(new VisualPosition(line, EditorUtil.getLastVisualLineColumnNumber(myEditor, line)));
          }
        }
        else {
          moveToVisualPosition(pos);
          if (!editorSettings.isVirtualSpace() && columnShift == 0 && lastColumnNumber >=0) {
            setLastColumnNumber(lastColumnNumber);
          }
        }

        if (withSelection) {
          if (blockSelection && !supportsMultipleCarets()) {
            selectionModel.setBlockSelection(blockSelectionStart, getLogicalPosition());
          }
          else {
            if (selectToDocumentStart) {
              if (supportsMultipleCarets()) {
                setSelection(leadSelectionPosition, leadSelectionOffset, myEditor.offsetToVisualPosition(0), 0);
              }
              else {
                setSelection(leadSelectionOffset, 0);
              }
            }
            else if (pos.line >= myEditor.getVisibleLineCount()) {
              int endOffset = document.getTextLength();
              if (leadSelectionOffset < endOffset) {
                if (supportsMultipleCarets()) {
                  setSelection(leadSelectionPosition, leadSelectionOffset, myEditor.offsetToVisualPosition(endOffset), endOffset);
                }
                else {
                  setSelection(leadSelectionOffset, endOffset);
                }
              }
            }
            else {
              int selectionStartToUse = leadSelectionOffset;
              VisualPosition selectionStartPositionToUse = leadSelectionPosition;
              if (isUnknownDirection()) {
                if (getOffset() > leadSelectionOffset ^ getSelectionStart() < getSelectionEnd()) {
                  selectionStartToUse = getSelectionEnd();
                  selectionStartPositionToUse = getSelectionEndPosition();
                }
                else {
                  selectionStartToUse = getSelectionStart();
                  selectionStartPositionToUse = getSelectionStartPosition();
                }
              }
              if (supportsMultipleCarets()) {
                setSelection(selectionStartPositionToUse, selectionStartToUse, getVisualPosition(), getOffset());
              }
              else {
                setSelection(selectionStartToUse, getVisualPosition(), getOffset());
              }
            }
          }
        }
        else {
          removeSelection();
        }

        if (scrollToCaret) {
          myEditor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
        }

        if (desiredX >= 0) {
          myDesiredX = desiredX;
        }

        EditorActionUtil.selectNonexpandableFold(myEditor);
      }
    });
  }

  @Override
  public void moveToLogicalPosition(@NotNull final LogicalPosition pos) {
    myEditor.getCaretModel().doWithCaretMerging(new Runnable() {
      public void run() {
        moveToLogicalPosition(pos, false, null, true);
      }
    });
  }


  private CaretEvent doMoveToLogicalPosition(@NotNull LogicalPosition pos,
                                             boolean locateBeforeSoftWrap,
                                             @NonNls @Nullable StringBuilder debugBuffer,
                                             boolean fireListeners) {
    assertIsDispatchThread();
    if (debugBuffer != null) {
      debugBuffer.append("Start moveToLogicalPosition(). Locate before soft wrap: ").append(locateBeforeSoftWrap).append(", position: ")
        .append(pos).append("\n");
    }
    myDesiredX = -1;
    validateCallContext();
    int column = pos.column;
    int line = pos.line;
    int softWrapLinesBefore = pos.softWrapLinesBeforeCurrentLogicalLine;
    int softWrapLinesCurrent = pos.softWrapLinesOnCurrentLogicalLine;
    int softWrapColumns = pos.softWrapColumnDiff;

    Document doc = myEditor.getDocument();

    if (column < 0) {
      if (debugBuffer != null) {
        debugBuffer.append("Resetting target logical column to zero as it is negative (").append(column).append(")\n");
      }
      column = 0;
      softWrapColumns = 0;
    }
    if (line < 0) {
      if (debugBuffer != null) {
        debugBuffer.append("Resetting target logical line to zero as it is negative (").append(line).append(")\n");
      }
      line = 0;
      softWrapLinesBefore = 0;
      softWrapLinesCurrent = 0;
    }

    int lineCount = doc.getLineCount();
    if (lineCount == 0) {
      if (debugBuffer != null) {
        debugBuffer.append("Resetting target logical line to zero as the document is empty\n");
      }
      line = 0;
    }
    else if (line > lineCount - 1) {
      if (debugBuffer != null) {
        debugBuffer.append("Resetting target logical line (").append(line).append(") to ").append(lineCount - 1)
          .append(" as it is greater than total document lines number\n");
      }
      line = lineCount - 1;
      softWrapLinesBefore = 0;
      softWrapLinesCurrent = 0;
    }

    EditorSettings editorSettings = myEditor.getSettings();

    if (!editorSettings.isVirtualSpace() && line < lineCount && !myEditor.getSelectionModel().hasBlockSelection()) {
      int lineEndOffset = doc.getLineEndOffset(line);
      final LogicalPosition endLinePosition = myEditor.offsetToLogicalPosition(lineEndOffset);
      int lineEndColumnNumber = endLinePosition.column;
      if (column > lineEndColumnNumber) {
        int oldColumn = column;
        column = lineEndColumnNumber;
        if (softWrapColumns != 0) {
          softWrapColumns -= column - lineEndColumnNumber;
        }
        if (debugBuffer != null) {
          debugBuffer.append("Resetting target logical column (").append(oldColumn).append(") to ").append(lineEndColumnNumber)
            .append(" because caret is not allowed to be located after line end (offset: ").append(lineEndOffset).append(", ")
            .append("logical position: ").append(endLinePosition).append("). Current soft wrap columns value: ").append(softWrapColumns)
            .append("\n");
        }
      }
    }

    myEditor.getFoldingModel().flushCaretPosition();

    VerticalInfo oldInfo = myCaretInfo;
    LogicalPosition oldCaretPosition = myLogicalCaret;

    LogicalPosition logicalPositionToUse;
    if (pos.visualPositionAware) {
      logicalPositionToUse = new LogicalPosition(
        line, column, softWrapLinesBefore, softWrapLinesCurrent, softWrapColumns, pos.foldedLines, pos.foldingColumnDiff
      );
    }
    else {
      logicalPositionToUse = new LogicalPosition(line, column);
    }
    setCurrentLogicalCaret(logicalPositionToUse);
    final int offset = myEditor.logicalPositionToOffset(myLogicalCaret);
    if (debugBuffer != null) {
      debugBuffer.append("Resulting logical position to use: ").append(myLogicalCaret).append(". It's mapped to offset ").append(offset).append("\n");
    }

    FoldRegion collapsedAt = myEditor.getFoldingModel().getCollapsedRegionAtOffset(offset);

    if (collapsedAt != null && offset > collapsedAt.getStartOffset()) {
      if (debugBuffer != null) {
        debugBuffer.append("Scheduling expansion of fold region ").append(collapsedAt).append("\n");
      }
      Runnable runnable = new Runnable() {
        @Override
        public void run() {
          FoldRegion[] allCollapsedAt = myEditor.getFoldingModel().fetchCollapsedAt(offset);
          for (FoldRegion foldRange : allCollapsedAt) {
            foldRange.setExpanded(true);
          }
        }
      };

      mySkipChangeRequests = true;
      try {
        myEditor.getFoldingModel().runBatchFoldingOperation(runnable, false);
      }
      finally {
        mySkipChangeRequests = false;
      }
    }

    setLastColumnNumber(myLogicalCaret.column);
    myDesiredSelectionStartColumn = myDesiredSelectionEndColumn = -1;
    myVisibleCaret = myEditor.logicalToVisualPosition(myLogicalCaret);

    updateOffsetsFromLogicalPosition();
    if (debugBuffer != null) {
      debugBuffer.append("Storing offset ").append(myOffset).append(" (mapped from logical position ").append(myLogicalCaret).append(")\n");
    }
    LOG.assertTrue(myOffset >= 0 && myOffset <= myEditor.getDocument().getTextLength());

    updateVisualLineInfo();

    myEditor.updateCaretCursor();
    requestRepaint(oldInfo);

    if (locateBeforeSoftWrap && SoftWrapHelper.isCaretAfterSoftWrap(this)) {
      int lineToUse = myVisibleCaret.line - 1;
      if (lineToUse >= 0) {
        final VisualPosition visualPosition = new VisualPosition(lineToUse, EditorUtil.getLastVisualLineColumnNumber(myEditor, lineToUse));
        if (debugBuffer != null) {
          debugBuffer.append("Adjusting caret position by moving it before soft wrap. Moving to visual position ").append(visualPosition).append("\n");
        }
        final LogicalPosition logicalPosition = myEditor.visualToLogicalPosition(visualPosition);
        final int tmpOffset = myEditor.logicalPositionToOffset(logicalPosition);
        if (tmpOffset == myOffset) {
          boolean restore = myReportCaretMoves;
          myReportCaretMoves = false;
          try {
            moveToVisualPosition(visualPosition);
            return null;
          }
          finally {
            myReportCaretMoves = restore;
          }
        }
        else {
          LogMessageEx.error(LOG, "Invalid editor dimension mapping", String.format(
            "Expected to map visual position '%s' to offset %d but got the following: -> logical position '%s'; -> offset %d. "
            + "State: %s", visualPosition, myOffset, logicalPosition, tmpOffset, myEditor.dumpState()
          ));
        }
      }
    }

    if (!oldCaretPosition.toVisualPosition().equals(myLogicalCaret.toVisualPosition())) {
      CaretEvent event = new CaretEvent(myEditor, supportsMultipleCarets() ? this : null, oldCaretPosition, myLogicalCaret);
      if (fireListeners) {
        myEditor.getCaretModel().fireCaretPositionChanged(event);
      }
      else {
        return event;
      }
    }
    return null;
  }

  private boolean supportsMultipleCarets() {
    return myEditor.getCaretModel().supportsMultipleCarets();
  }

  private void updateOffsetsFromLogicalPosition() {
    myOffset = myEditor.logicalPositionToOffset(myLogicalCaret);
    myVirtualSpaceOffset = myLogicalCaret.column - myEditor.offsetToLogicalPosition(myOffset).column;
  }

  private void setLastColumnNumber(int lastColumnNumber) {
    myLastColumnNumber = lastColumnNumber;
    myEditor.setLastColumnNumber(lastColumnNumber);
  }

  private void requestRepaint(VerticalInfo oldCaretInfo) {
    int lineHeight = myEditor.getLineHeight();
    Rectangle visibleArea = myEditor.getScrollingModel().getVisibleArea();
    final EditorGutterComponentEx gutter = myEditor.getGutterComponentEx();
    final EditorComponentImpl content = myEditor.getContentComponent();

    int updateWidth = myEditor.getScrollPane().getHorizontalScrollBar().getValue() + visibleArea.width;
    if (Math.abs(myCaretInfo.y - oldCaretInfo.y) <= 2 * lineHeight) {
      int minY = Math.min(oldCaretInfo.y, myCaretInfo.y);
      int maxY = Math.max(oldCaretInfo.y + oldCaretInfo.height, myCaretInfo.y + myCaretInfo.height);
      content.repaintEditorComponent(0, minY, updateWidth, maxY - minY);
      gutter.repaint(0, minY, gutter.getWidth(), maxY - minY);
    }
    else {
      content.repaintEditorComponent(0, oldCaretInfo.y, updateWidth, oldCaretInfo.height + lineHeight);
      gutter.repaint(0, oldCaretInfo.y, updateWidth, oldCaretInfo.height + lineHeight);
      content.repaintEditorComponent(0, myCaretInfo.y, updateWidth, myCaretInfo.height + lineHeight);
      gutter.repaint(0, myCaretInfo.y, updateWidth, myCaretInfo.height + lineHeight);
    }
  }

  @Override
  public void moveToVisualPosition(@NotNull final VisualPosition pos) {
    myEditor.getCaretModel().doWithCaretMerging(new Runnable() {
      public void run() {
        moveToVisualPosition(pos, true);
      }
    });
  }

  void moveToVisualPosition(@NotNull VisualPosition pos, boolean fireListeners) {
    assertIsDispatchThread();
    validateCallContext();
    if (mySkipChangeRequests) {
      return;
    }
    if (myReportCaretMoves) {
      LogMessageEx.error(LOG, "Unexpected caret move request");
    }
    if (!myEditor.isStickySelection() && !myEditor.getCaretModel().isDocumentChanged && !pos.equals(myVisibleCaret)) {
      CopyPasteManager.getInstance().stopKillRings();
    }

    myDesiredX = -1;
    int column = pos.column;
    int line = pos.line;

    if (column < 0) column = 0;

    if (line < 0) line = 0;

    int lastLine = myEditor.getVisibleLineCount() - 1;
    if (lastLine <= 0) {
      lastLine = 0;
    }

    if (line > lastLine) {
      line = lastLine;
    }

    EditorSettings editorSettings = myEditor.getSettings();

    if (!editorSettings.isVirtualSpace() && line <= lastLine) {
      int lineEndColumn = EditorUtil.getLastVisualLineColumnNumber(myEditor, line);
      if (column > lineEndColumn) {
        column = lineEndColumn;
      }

      if (column < 0 && line > 0) {
        line--;
        column = EditorUtil.getLastVisualLineColumnNumber(myEditor, line);
      }
    }

    myVisibleCaret = new VisualPosition(line, column);

    VerticalInfo oldInfo = myCaretInfo;
    LogicalPosition oldPosition = myLogicalCaret;

    setCurrentLogicalCaret(myEditor.visualToLogicalPosition(myVisibleCaret));
    updateOffsetsFromLogicalPosition();
    LOG.assertTrue(myOffset >= 0 && myOffset <= myEditor.getDocument().getTextLength());

    updateVisualLineInfo();

    myEditor.getFoldingModel().flushCaretPosition();

    setLastColumnNumber(myLogicalCaret.column);
    myDesiredSelectionStartColumn = myDesiredSelectionEndColumn = -1;
    myEditor.updateCaretCursor();
    requestRepaint(oldInfo);

    if (fireListeners && !oldPosition.equals(myLogicalCaret)) {
      CaretEvent event = new CaretEvent(myEditor, supportsMultipleCarets() ? this : null, oldPosition, myLogicalCaret);
      myEditor.getCaretModel().fireCaretPositionChanged(event);
    }
  }

  @Nullable
  CaretEvent moveToLogicalPosition(@NotNull LogicalPosition pos,
                                           boolean locateBeforeSoftWrap,
                                           @Nullable StringBuilder debugBuffer,
                                           boolean fireListeners) {
    if (mySkipChangeRequests) {
      return null;
    }
    if (myReportCaretMoves) {
      LogMessageEx.error(LOG, "Unexpected caret move request");
    }
    if (!myEditor.isStickySelection() && !myEditor.getCaretModel().isDocumentChanged && !pos.equals(myLogicalCaret)) {
      CopyPasteManager.getInstance().stopKillRings();
    }

    myReportCaretMoves = true;
    try {
      return doMoveToLogicalPosition(pos, locateBeforeSoftWrap, debugBuffer, fireListeners);
    }
    finally {
      myReportCaretMoves = false;
    }
  }

  private void assertIsDispatchThread() {
    myEditor.assertIsDispatchThread();
  }

  private void validateCallContext() {
    LOG.assertTrue(!myEditor.getCaretModel().myIsInUpdate, "Caret model is in its update process. All requests are illegal at this point.");
  }

  private void releaseBulkCaretMarker() {
    if (savedBeforeBulkCaretMarker != null) {
      savedBeforeBulkCaretMarker.dispose();
      savedBeforeBulkCaretMarker = null;
    }
  }

  @Override
  public void dispose() {
    if (mySelectionMarker != null) {
      mySelectionMarker.release();
      mySelectionMarker = null;
    }
    releaseBulkCaretMarker();
    isValid = false;
  }

  @Override
  public boolean isUpToDate() {
    return !myEditor.getCaretModel().myIsInUpdate && !myReportCaretMoves;
  }

  @NotNull
  @Override
  public LogicalPosition getLogicalPosition() {
    validateCallContext();
    return myLogicalCaret;
  }

  @NotNull
  @Override
  public VisualPosition getVisualPosition() {
    validateCallContext();
    return myVisibleCaret;
  }

  @Override
  public int getOffset() {
    validateCallContext();
    return myOffset;
  }

  @Override
  public int getVisualLineStart() {
    return myVisualLineStart;
  }

  @Override
  public int getVisualLineEnd() {
    return myVisualLineEnd;
  }

  @NotNull
  private VerticalInfo createVerticalInfo(LogicalPosition position) {
    Document document = myEditor.getDocument();
    int logicalLine = position.line;
    if (logicalLine >= document.getLineCount()) {
      logicalLine = Math.max(0, document.getLineCount() - 1);
    }
    int startOffset = document.getLineStartOffset(logicalLine);
    int endOffset = document.getLineEndOffset(logicalLine);

    // There is a possible case that active logical line is represented on multiple lines due to soft wraps processing.
    // We want to highlight those visual lines as 'active' then, so, we calculate 'y' position for the logical line start
    // and height in accordance with the number of occupied visual lines.
    VisualPosition visualPosition = myEditor.offsetToVisualPosition(document.getLineStartOffset(logicalLine));
    int y = myEditor.visualPositionToXY(visualPosition).y;
    int lineHeight = myEditor.getLineHeight();
    int height = lineHeight;
    List<? extends SoftWrap> softWraps = myEditor.getSoftWrapModel().getSoftWrapsForRange(startOffset, endOffset);
    for (SoftWrap softWrap : softWraps) {
      height += StringUtil.countNewLines(softWrap.getText()) * lineHeight;
    }

    return new VerticalInfo(y, height);
  }

  /**
   * Recalculates caret visual position without changing its logical position (called when soft wraps are changing)
   */
  public void updateVisualPosition() {
    VerticalInfo oldInfo = myCaretInfo;
    LogicalPosition visUnawarePos = new LogicalPosition(myLogicalCaret.line, myLogicalCaret.column);
    setCurrentLogicalCaret(visUnawarePos);
    myVisibleCaret = myEditor.logicalToVisualPosition(myLogicalCaret);
    updateVisualLineInfo();

    myEditor.updateCaretCursor();
    requestRepaint(oldInfo);
  }

  private void updateVisualLineInfo() {
    myVisualLineStart = myEditor.logicalPositionToOffset(myEditor.visualToLogicalPosition(new VisualPosition(myVisibleCaret.line, 0)));
    myVisualLineEnd = myEditor.logicalPositionToOffset(myEditor.visualToLogicalPosition(new VisualPosition(myVisibleCaret.line + 1, 0)));
  }

  void updateCaretPosition(@NotNull final DocumentEventImpl event) {
    final DocumentEx document = myEditor.getDocument();
    boolean performSoftWrapAdjustment = event.getNewLength() > 0 // We want to put caret just after the last added symbol
                                        // There is a possible case that the user removes text just before the soft wrap. We want to keep caret
                                        // on a visual line with soft wrap start then.
                                        || myEditor.getSoftWrapModel().getSoftWrap(event.getOffset()) != null;

    if (event.isWholeTextReplaced()) {
      int newLength = document.getTextLength();
      if (myOffset == newLength - event.getNewLength() + event.getOldLength() || newLength == 0) {
        moveToOffset(newLength, performSoftWrapAdjustment);
      }
      else {
        try {
          final int line = event.translateLineViaDiff(myLogicalCaret.line);
          moveToLogicalPosition(new LogicalPosition(line, myLogicalCaret.column), performSoftWrapAdjustment, null, true);
        }
        catch (FilesTooBigForDiffException e1) {
          LOG.info(e1);
          moveToOffset(0);
        }
      }
    }
    else {
      if (document.isInBulkUpdate()) return;
      int startOffset = event.getOffset();
      int oldEndOffset = startOffset + event.getOldLength();

      int newOffset = myOffset;

      if (myOffset > oldEndOffset || myOffset == oldEndOffset && needToShiftWhiteSpaces(event)) {
        newOffset += event.getNewLength() - event.getOldLength();
      }
      else if (myOffset >= startOffset && myOffset <= oldEndOffset) {
        newOffset = Math.min(newOffset, startOffset + event.getNewLength());
      }

      newOffset = Math.min(newOffset, document.getTextLength());

      if (supportsMultipleCarets() && myOffset != startOffset) {
        LogicalPosition pos = myEditor.offsetToLogicalPosition(newOffset);
        moveToLogicalPosition(new LogicalPosition(pos.line, pos.column + myVirtualSpaceOffset), // retain caret in the virtual space
                            performSoftWrapAdjustment, null, true);
      }
      else {
        moveToOffset(newOffset, performSoftWrapAdjustment);
      }
    }

    updateVisualLineInfo();
  }

  private boolean needToShiftWhiteSpaces(final DocumentEvent e) {
    if (!CharArrayUtil.containsOnlyWhiteSpaces(e.getNewFragment()) || CharArrayUtil.containLineBreaks(e.getNewFragment()))
      return e.getOldLength() > 0;
    if (e.getOffset() == 0) return false;
    final char charBefore = myEditor.getDocument().getCharsSequence().charAt(e.getOffset() - 1);
    //final char charAfter = myEditor.getDocument().getCharsSequence().charAt(e.getOffset() + e.getNewLength());
    return Character.isWhitespace(charBefore)/* || !Character.isWhitespace(charAfter)*/;
  }

  private void setCurrentLogicalCaret(@NotNull LogicalPosition position) {
    myLogicalCaret = position;
    myCaretInfo = createVerticalInfo(position);
  }

  int getWordAtCaretStart() {
    Document document = myEditor.getDocument();
    int offset = getOffset();
    if (offset == 0) return 0;
    int lineNumber = getLogicalPosition().line;
    CharSequence text = document.getCharsSequence();
    int newOffset = offset - 1;
    int minOffset = lineNumber > 0 ? document.getLineEndOffset(lineNumber - 1) : 0;
    boolean camel = myEditor.getSettings().isCamelWords();
    for (; newOffset > minOffset; newOffset--) {
      if (EditorActionUtil.isWordStart(text, newOffset, camel)) break;
    }

    return newOffset;
  }

  int getWordAtCaretEnd() {
    Document document = myEditor.getDocument();
    int offset = getOffset();

    CharSequence text = document.getCharsSequence();
    if (offset >= document.getTextLength() - 1 || document.getLineCount() == 0) return offset;

    int newOffset = offset + 1;

    int lineNumber = getLogicalPosition().line;
    int maxOffset = document.getLineEndOffset(lineNumber);
    if (newOffset > maxOffset) {
      if (lineNumber + 1 >= document.getLineCount()) return offset;
      maxOffset = document.getLineEndOffset(lineNumber + 1);
    }
    boolean camel = myEditor.getSettings().isCamelWords();
    for (; newOffset < maxOffset; newOffset++) {
      if (EditorActionUtil.isWordEnd(text, newOffset, camel)) break;
    }

    return newOffset;
  }

  CaretImpl cloneWithoutSelection() {
    CaretImpl clone = new CaretImpl(myEditor);
    clone.myLogicalCaret = this.myLogicalCaret;
    clone.myCaretInfo = this.myCaretInfo;
    clone.myVisibleCaret = this.myVisibleCaret;
    clone.myOffset = this.myOffset;
    clone.myVirtualSpaceOffset = this.myVirtualSpaceOffset;
    clone.myVisualLineStart = this.myVisualLineStart;
    clone.myVisualLineEnd = this.myVisualLineEnd;
    clone.savedBeforeBulkCaretMarker = this.savedBeforeBulkCaretMarker;
    clone.mySkipChangeRequests = this.mySkipChangeRequests;
    clone.myLastColumnNumber = this.myLastColumnNumber;
    clone.myReportCaretMoves = this.myReportCaretMoves;
    clone.myDesiredX = this.myDesiredX;
    clone.myDesiredSelectionStartColumn = -1;
    clone.myDesiredSelectionEndColumn = -1;
    return clone;
  }

  @Nullable
  @Override
  public Caret clone(boolean above) {
    assertIsDispatchThread();
    int lineShift = above ? -1 : 1;
    final CaretImpl clone = cloneWithoutSelection();
    final int newSelectionStartOffset, newSelectionEndOffset, newSelectionStartColumn, newSelectionEndColumn;
    final VisualPosition newSelectionStartPosition, newSelectionEndPosition;
    final boolean hasNewSelection;
    if (hasSelection() || myDesiredSelectionStartColumn >=0 || myDesiredSelectionEndColumn >= 0) {
      VisualPosition startPosition = getSelectionStartPosition();
      VisualPosition endPosition = getSelectionEndPosition();
      VisualPosition leadPosition = getLeadSelectionPosition();
      boolean leadIsStart = leadPosition.equals(startPosition);
      boolean leadIsEnd = leadPosition.equals(endPosition);
      LogicalPosition selectionStart = myEditor.visualToLogicalPosition(leadIsStart || leadIsEnd ? leadPosition : startPosition);
      LogicalPosition selectionEnd = myEditor.visualToLogicalPosition(leadIsEnd ? startPosition : endPosition);
      newSelectionStartColumn = myDesiredSelectionStartColumn < 0 ? selectionStart.column : myDesiredSelectionStartColumn;
      newSelectionEndColumn = myDesiredSelectionEndColumn < 0 ? selectionEnd.column : myDesiredSelectionEndColumn;
      LogicalPosition newSelectionStart = truncate(selectionStart.line + lineShift, newSelectionStartColumn);
      LogicalPosition newSelectionEnd = truncate(selectionEnd.line + lineShift, newSelectionEndColumn);
      newSelectionStartOffset = myEditor.logicalPositionToOffset(newSelectionStart);
      newSelectionEndOffset = myEditor.logicalPositionToOffset(newSelectionEnd);
      newSelectionStartPosition = myEditor.logicalToVisualPosition(newSelectionStart);
      newSelectionEndPosition = myEditor.logicalToVisualPosition(newSelectionEnd);
      hasNewSelection = !newSelectionStart.equals(newSelectionEnd);
    }
    else {
      newSelectionStartOffset = 0;
      newSelectionEndOffset = 0;
      newSelectionStartPosition = null;
      newSelectionEndPosition = null;
      hasNewSelection = false;
      newSelectionStartColumn = -1;
      newSelectionEndColumn = -1;
    }
    LogicalPosition oldPosition = getLogicalPosition();
    int newLine = oldPosition.line + lineShift;
    if (newLine < 0 || newLine >= myEditor.getDocument().getLineCount()) {
      Disposer.dispose(clone);
      return null;
    }
    clone.moveToLogicalPosition(new LogicalPosition(newLine, myLastColumnNumber), false, null, false);
    clone.myLastColumnNumber = myLastColumnNumber;
    clone.myDesiredX = myDesiredX >= 0 ? myDesiredX : getCurrentX();
    clone.myDesiredSelectionStartColumn = newSelectionStartColumn;
    clone.myDesiredSelectionEndColumn = newSelectionEndColumn;

    if (myEditor.getCaretModel().addCaret(clone)) {
      if (hasNewSelection) {
        myEditor.getCaretModel().doWithCaretMerging(new Runnable() {
          @Override
          public void run() {
            clone.setSelection(newSelectionStartPosition, newSelectionStartOffset, newSelectionEndPosition, newSelectionEndOffset);
          }
        });
        if (!clone.isValid()) {
          return null;
        }
      }
      myEditor.getScrollingModel().scrollTo(clone.getLogicalPosition(), ScrollType.RELATIVE);
      return clone;
    }
    else {
      Disposer.dispose(clone);
      return null;
    }
  }

  private LogicalPosition truncate(int line, int column) {
    if (line < 0) {
      return new LogicalPosition(0, 0);
    }
    else if (line >= myEditor.getDocument().getLineCount()) {
      return myEditor.offsetToLogicalPosition(myEditor.getDocument().getTextLength());
    }
    else {
      return new LogicalPosition(line, column);
    }
  }

  /**
   * @return  information on whether current selection's direction in known
   * @see #setUnknownDirection(boolean)
   */
  public boolean isUnknownDirection() {
    return myUnknownDirection;
  }

  /**
   * There is a possible case that we don't know selection's direction. For example, a user might triple-click editor (select the
   * whole line). We can't say what selection end is a {@link #getLeadSelectionOffset() leading end} then. However, that matters
   * in a situation when a user clicks before or after that line holding Shift key. It's expected that the selection is expanded
   * up to that point than.
   * <p/>
   * That's why we allow to specify that the direction is unknown and {@link #isUnknownDirection() expose this information}
   * later.
   * <p/>
   * <b>Note:</b> when this method is called with <code>'true'</code>, subsequent calls are guaranteed to return <code>'true'</code>
   * until selection is changed. 'Unknown direction' flag is automatically reset then.
   *
   * @param unknownDirection
   */
  public void setUnknownDirection(boolean unknownDirection) {
    myUnknownDirection = unknownDirection;
  }

  @Override
  public int getSelectionStart() {
    validateContext(false);
    if (hasSelection()) {
      MyRangeMarker marker = mySelectionMarker;
      if (marker != null) {
        return marker.getStartOffset();
      }
    }
    return getOffset();
  }

  @NotNull
  @Override
  public VisualPosition getSelectionStartPosition() {
    validateContext(false);
    VisualPosition position;
    if (hasSelection() && mySelectionMarker != null) {
      position = mySelectionMarker.getStartPosition();
      if (position == null) {
        position = myEditor.offsetToVisualPosition(mySelectionMarker.getStartOffset());
      }
    }
    else {
      position = isVirtualSelectionEnabled() ? getVisualPosition() : myEditor.offsetToVisualPosition(getOffset());
    }
    if (hasVirtualSelection()) {
      position = new VisualPosition(position.line, position.column + myStartVirtualOffset);
    }
    return position;
  }

  @Override
  public int getSelectionEnd() {
    validateContext(false);
    if (hasSelection()) {
      MyRangeMarker marker = mySelectionMarker;
      if (marker != null) {
        return marker.getEndOffset();
      }
    }
    return getOffset();
  }

  @NotNull
  @Override
  public VisualPosition getSelectionEndPosition() {
    validateContext(false);
    VisualPosition position;
    if (hasSelection() && mySelectionMarker != null) {
      position = mySelectionMarker.getEndPosition();
      if (position == null) {
        position = myEditor.offsetToVisualPosition(mySelectionMarker.getEndOffset());
      }
    }
    else {
      position = isVirtualSelectionEnabled() ? getVisualPosition() : myEditor.offsetToVisualPosition(getOffset());
    }
    if (hasVirtualSelection()) {
      position = new VisualPosition(position.line, position.column + myEndVirtualOffset);
    }
    return position;
  }

  @Override
  public boolean hasSelection() {
    validateContext(false);
    MyRangeMarker marker = mySelectionMarker;
    return marker != null && marker.isValid() && (marker.getEndOffset() > marker.getStartOffset()
                                                  || isVirtualSelectionEnabled() && myEndVirtualOffset > myStartVirtualOffset);
  }

  @Override
  public void setSelection(int startOffset, int endOffset) {
    setSelection(startOffset, endOffset, true);
  }

  @Override
  public void setSelection(int startOffset, int endOffset, boolean updateSystemSelection) {
    doSetSelection(myEditor.offsetToVisualPosition(startOffset), startOffset, myEditor.offsetToVisualPosition(endOffset), endOffset, false,
                   updateSystemSelection);
  }

  @Override
  public void setSelection(int startOffset, @Nullable VisualPosition endPosition, int endOffset) {
    VisualPosition startPosition;
    if (hasSelection()) {
      startPosition = getLeadSelectionPosition();
    }
    else {
      startPosition = myEditor.offsetToVisualPosition(startOffset);
    }
    setSelection(startPosition, startOffset, endPosition, endOffset);
  }

  @Override
  public void setSelection(@Nullable VisualPosition startPosition, int startOffset, @Nullable VisualPosition endPosition, int endOffset) {
    setSelection(startPosition, startOffset, endPosition, endOffset, true);
  }

  @Override
  public void setSelection(@Nullable VisualPosition startPosition, int startOffset, @Nullable VisualPosition endPosition, int endOffset, boolean updateSystemSelection) {
    VisualPosition startPositionToUse = startPosition == null ? myEditor.offsetToVisualPosition(startOffset) : startPosition;
    VisualPosition endPositionToUse = endPosition == null ? myEditor.offsetToVisualPosition(endOffset) : endPosition;
    doSetSelection(startPositionToUse, startOffset, endPositionToUse, endOffset, true, updateSystemSelection);
  }

  private void doSetSelection(@NotNull final VisualPosition startPosition,
                              final int _startOffset,
                              @NotNull final VisualPosition endPosition,
                              final int _endOffset,
                              final boolean visualPositionAware,
                              final boolean updateSystemSelection)
  {
    myEditor.getCaretModel().doWithCaretMerging(new Runnable() {
      public void run() {
        int startOffset = _startOffset;
        int endOffset = _endOffset;
        myUnknownDirection = false;
        final Document doc = myEditor.getDocument();

        validateContext(true);

        myEditor.getSelectionModel().removeBlockSelection();

        int textLength = doc.getTextLength();
        if (startOffset < 0 || startOffset > textLength) {
          LOG.error("Wrong startOffset: " + startOffset + ", textLength=" + textLength);
        }
        if (endOffset < 0 || endOffset > textLength) {
          LOG.error("Wrong endOffset: " + endOffset + ", textLength=" + textLength);
        }

        if (!visualPositionAware && startOffset == endOffset) {
          removeSelection();
          return;
        }

    /* Normalize selection */
        boolean switchedOffsets = false;
        if (startOffset > endOffset) {
          int tmp = startOffset;
          startOffset = endOffset;
          endOffset = tmp;
          switchedOffsets = true;
        }

        FoldingModelEx foldingModel = myEditor.getFoldingModel();
        FoldRegion startFold = foldingModel.getCollapsedRegionAtOffset(startOffset);
        if (startFold != null && startFold.getStartOffset() < startOffset) {
          startOffset = startFold.getStartOffset();
        }

        FoldRegion endFold = foldingModel.getCollapsedRegionAtOffset(endOffset);
        if (endFold != null && endFold.getStartOffset() < endOffset) {
          // All visual positions that lay at collapsed fold region placeholder are mapped to the same offset. Hence, there are
          // at least two distinct situations - selection end is located inside collapsed fold region placeholder and just before it.
          // We want to expand selection to the fold region end at the former case and keep selection as-is at the latest one.
          endOffset = endFold.getEndOffset();
        }

        int oldSelectionStart;
        int oldSelectionEnd;

        if (hasSelection()) {
          oldSelectionStart = getSelectionStart();
          oldSelectionEnd = getSelectionEnd();
          if (oldSelectionStart == startOffset && oldSelectionEnd == endOffset && !visualPositionAware) return;
        }
        else {
          oldSelectionStart = oldSelectionEnd = getOffset();
        }

        MyRangeMarker marker = mySelectionMarker;
        if (marker != null) {
          marker.release();
        }

        marker = new MyRangeMarker((DocumentEx)doc, startOffset, endOffset);
        myStartVirtualOffset = 0;
        myEndVirtualOffset = 0;
        if (visualPositionAware) {
          if (endPosition.after(startPosition)) {
            marker.setStartPosition(startPosition);
            marker.setEndPosition(endPosition);
            marker.setEndPositionIsLead(false);
          }
          else {
            marker.setStartPosition(endPosition);
            marker.setEndPosition(startPosition);
            marker.setEndPositionIsLead(true);
          }

          if (isVirtualSelectionEnabled() &&
              myEditor.getDocument().getLineNumber(startOffset) == myEditor.getDocument().getLineNumber(endOffset)) {
            int endLineColumn = myEditor.offsetToVisualPosition(endOffset).column;
            int startDiff =
              EditorUtil.isAtLineEnd(myEditor, switchedOffsets ? endOffset : startOffset) ? startPosition.column - endLineColumn : 0;
            int endDiff =
              EditorUtil.isAtLineEnd(myEditor, switchedOffsets ? startOffset : endOffset) ? endPosition.column - endLineColumn : 0;
            myStartVirtualOffset = Math.max(0, Math.min(startDiff, endDiff));
            myEndVirtualOffset = Math.max(0, Math.max(startDiff, endDiff));
          }
        }
        mySelectionMarker = marker;

        myEditor.getSelectionModel().fireSelectionChanged(oldSelectionStart, oldSelectionEnd, startOffset, endOffset);

        if (updateSystemSelection) {
          updateSystemSelection();
        }
      }
    });
  }

  private void updateSystemSelection() {
    if (GraphicsEnvironment.isHeadless()) return;

    final Clipboard clip = myEditor.getComponent().getToolkit().getSystemSelection();
    if (clip != null) {
      clip.setContents(new StringSelection(myEditor.getSelectionModel().getSelectedText(true)), EmptyClipboardOwner.INSTANCE);
    }
  }

  @Override
  public void removeSelection() {
    if (myEditor.isStickySelection()) {
      // Most of our 'change caret position' actions (like move caret to word start/end etc) remove active selection.
      // However, we don't want to do that for 'sticky selection'.
      return;
    }
    myEditor.getCaretModel().doWithCaretMerging(new Runnable() {
      public void run() {
        validateContext(true);
        myEditor.getSelectionModel().removeBlockSelection();
        int caretOffset = getOffset();
        MyRangeMarker marker = mySelectionMarker;
        if (marker != null) {
          int startOffset = marker.getStartOffset();
          int endOffset = marker.getEndOffset();
          marker.release();
          mySelectionMarker = null;
          myStartVirtualOffset = 0;
          myEndVirtualOffset = 0;
          myEditor.getSelectionModel().fireSelectionChanged(startOffset, endOffset, caretOffset, caretOffset);
        }
      }
    });
  }

  @Override
  public int getLeadSelectionOffset() {
    validateContext(false);
    int caretOffset = getOffset();
    if (hasSelection()) {
      MyRangeMarker marker = mySelectionMarker;
      if (marker != null) {
        int startOffset = marker.getStartOffset();
        int endOffset = marker.getEndOffset();
        if (caretOffset != startOffset && caretOffset != endOffset) {
          // Try to check if current selection is tweaked by fold region.
          FoldingModelEx foldingModel = myEditor.getFoldingModel();
          FoldRegion foldRegion = foldingModel.getCollapsedRegionAtOffset(caretOffset);
          if (foldRegion != null) {
            if (foldRegion.getStartOffset() == startOffset) {
              return endOffset;
            }
            else if (foldRegion.getEndOffset() == endOffset) {
              return startOffset;
            }
          }
        }

        if (caretOffset == endOffset) {
          return startOffset;
        }
        else {
          return endOffset;
        }
      }
    }
    return caretOffset;
  }

  @NotNull
  @Override
  public VisualPosition getLeadSelectionPosition() {
    MyRangeMarker marker = mySelectionMarker;
    VisualPosition caretPosition = getVisualPosition();
    if (isVirtualSelectionEnabled() && !hasSelection()) {
      return caretPosition;
    }
    if (marker == null) {
      return caretPosition;
    }

    if (marker.isEndPositionIsLead()) {
      VisualPosition result = marker.getEndPosition();
      if (result == null) {
        return getSelectionEndPosition();
      }
      else {
        if (hasVirtualSelection()) {
          result = new VisualPosition(result.line, result.column + myEndVirtualOffset);
        }
        return result;
      }
    }
    else {
      VisualPosition result = marker.getStartPosition();
      if (result == null) {
        return getSelectionStartPosition();
      }
      else {
        if (hasVirtualSelection()) {
          result = new VisualPosition(result.line, result.column + myStartVirtualOffset);
        }
        return result;
      }
    }
  }

  @Override
  public void selectLineAtCaret() {
    validateContext(true);
    myEditor.getCaretModel().doWithCaretMerging(new Runnable() {
      public void run() {
        SelectionModelImpl.doSelectLineAtCaret(myEditor);
      }
    });
  }

  @Override
  public void selectWordAtCaret(final boolean honorCamelWordsSettings) {
    validateContext(true);
    myEditor.getCaretModel().doWithCaretMerging(new Runnable() {
      public void run() {
        removeSelection();
        final EditorSettings settings = myEditor.getSettings();
        boolean camelTemp = settings.isCamelWords();

        final boolean needOverrideSetting = camelTemp && !honorCamelWordsSettings;
        if (needOverrideSetting) {
          settings.setCamelWords(false);
        }

        try {
          EditorActionHandler handler = EditorActionManager.getInstance().getActionHandler(IdeActions.ACTION_EDITOR_SELECT_WORD_AT_CARET);
          handler.execute(myEditor, CaretImpl.this, myEditor.getDataContext());
        }
        finally {
          if (needOverrideSetting) {
            settings.resetCamelWords();
          }
        }
      }
    });
  }

  @Nullable
  @Override
  public String getSelectedText() {
    if (!hasSelection()) {
      return null;
    }
    CharSequence text = myEditor.getDocument().getCharsSequence();
    int selectionStart = getSelectionStart();
    int selectionEnd = getSelectionEnd();
    String selectedText = text.subSequence(selectionStart, selectionEnd).toString();
    if (isVirtualSelectionEnabled() && myEndVirtualOffset > myStartVirtualOffset) {
      int padding = myEndVirtualOffset - myStartVirtualOffset;
      StringBuilder builder = new StringBuilder(selectedText.length() + padding);
      builder.append(selectedText);
      for (int i = 0; i < padding; i++) {
        builder.append(' ');
      }
      return builder.toString();
    }
    else {
      return selectedText;
    }
  }

  private void validateContext(boolean isWrite) {
    if (!myEditor.getComponent().isShowing()) return;
    if (isWrite) {
      ApplicationManager.getApplication().assertIsDispatchThread();
    }
    else {
      ApplicationManager.getApplication().assertReadAccessAllowed();
    }
  }

  private boolean isVirtualSelectionEnabled() {
    return myEditor.isColumnMode() && supportsMultipleCarets();
  }

  boolean hasVirtualSelection() {
    validateContext(false);
    MyRangeMarker marker = mySelectionMarker;
    return marker != null && marker.isValid() && isVirtualSelectionEnabled() && myEndVirtualOffset > myStartVirtualOffset;
  }

  private int getCurrentX() {
    return myEditor.visualPositionToXY(myVisibleCaret).x;
  }

  @Override
  @NotNull
  public EditorImpl getEditor() {
    return myEditor;
  }

  @Override
  public String toString() {
    return "Caret at " + myVisibleCaret + (mySelectionMarker == null ? "" : (", selection marker: " + mySelectionMarker.toString()));
  }

  /**
   * Encapsulates information about target vertical range info - its <code>'y'</code> coordinate and height in pixels.
   */
  public static class VerticalInfo {
    public final int y;
    public final int height;

    private VerticalInfo(int y, int height) {
      this.y = y;
      this.height = height;
    }
  }

  private class MyRangeMarker extends RangeMarkerImpl {
    private VisualPosition myStartPosition;
    private VisualPosition myEndPosition;
    private boolean myEndPositionIsLead;
    private boolean myIsReleased;

    MyRangeMarker(DocumentEx document, int start, int end) {
      super(document, start, end, true);
      myIsReleased = false;
    }

    public void release() {
      myIsReleased = true;
      dispose();
    }

    @Nullable
    public VisualPosition getStartPosition() {
      invalidateVisualPositions();
      return myStartPosition;
    }

    public void setStartPosition(@NotNull VisualPosition startPosition) {
      myStartPosition = startPosition;
    }

    @Nullable
    public VisualPosition getEndPosition() {
      invalidateVisualPositions();
      return myEndPosition;
    }

    public void setEndPosition(@NotNull VisualPosition endPosition) {
      myEndPosition = endPosition;
    }

    public boolean isEndPositionIsLead() {
      return myEndPositionIsLead;
    }

    public void setEndPositionIsLead(boolean endPositionIsLead) {
      myEndPositionIsLead = endPositionIsLead;
    }

    int startBefore;
    int endBefore;

    @Override
    protected void changedUpdateImpl(DocumentEvent e) {
      if (myIsReleased) return;
      startBefore = getStartOffset();
      endBefore = getEndOffset();
      super.changedUpdateImpl(e);
    }

    private void invalidateVisualPositions() {
      SoftWrapModelImpl model = myEditor.getSoftWrapModel();
      if (!myEditor.offsetToVisualPosition(getStartOffset()).equals(myStartPosition) && model.getSoftWrap(getStartOffset()) == null
          || !myEditor.offsetToVisualPosition(getEndOffset()).equals(myEndPosition) && model.getSoftWrap(getEndOffset()) == null) {
        myStartPosition = null;
        myEndPosition = null;
      }
    }
  }
}