Java EditorImpl类代码示例

import com.intellij.openapi.editor.impl.EditorImpl; //导入依赖的package包/类
private Document findDocument()
{
  Editor editor = ResourceToManifoldUtil.getActiveEditor( getProject() );
  if( editor instanceof EditorImpl )
  {
    EditorImpl editorImpl = (EditorImpl)editor;
    if( editorImpl.getVirtualFile().getPath().equals( _file.getVirtualFile().getPath() ) )
    {
      // get document from current editor
      return editorImpl.getDocument();
    }
  }

  // get document from file
  return _file.getViewProvider().getDocument();
}
 

import com.intellij.openapi.editor.impl.EditorImpl; //导入依赖的package包/类
@NotNull
protected static Editor configureFromFileTextWithoutPSI(@NonNls @NotNull final String fileText) {
  return new WriteCommandAction<Editor>(null) {
    @Override
    protected void run(@NotNull Result<Editor> result) throws Throwable {
      final Document fakeDocument = EditorFactory.getInstance().createDocument(fileText);
      EditorTestUtil.CaretAndSelectionState caretsState = EditorTestUtil.extractCaretAndSelectionMarkers(fakeDocument);

      String newFileText = fakeDocument.getText();
      Document document = EditorFactory.getInstance().createDocument(newFileText);
      final Editor editor = EditorFactory.getInstance().createEditor(document);
      ((EditorImpl)editor).setCaretActive();

      EditorTestUtil.setCaretsAndSelection(editor, caretsState);
      result.setResult(editor);
    }
  }.execute().getResultObject();
}
 

import com.intellij.openapi.editor.impl.EditorImpl; //导入依赖的package包/类
public static void moveCaretRelativelyAndScroll(@NotNull Editor editor,
                                                int columnShift,
                                                int lineShift,
                                                boolean withSelection) {
  Rectangle visibleArea = editor.getScrollingModel().getVisibleArea();
  VisualPosition pos = editor.getCaretModel().getVisualPosition();
  Point caretLocation = editor.visualPositionToXY(pos);
  int caretVShift = caretLocation.y - visibleArea.y;

  editor.getCaretModel().moveCaretRelatively(columnShift, lineShift, withSelection, false, false);

  VisualPosition caretPos = editor.getCaretModel().getVisualPosition();
  Point caretLocation2 = editor.visualPositionToXY(caretPos);
  final boolean scrollToCaret = !(editor instanceof EditorImpl) || ((EditorImpl)editor).isScrollToCaret();
  if (scrollToCaret) {
    editor.getScrollingModel().scrollVertically(caretLocation2.y - caretVShift);
  }
}
 

import com.intellij.openapi.editor.impl.EditorImpl; //导入依赖的package包/类
@Override
public void execute(Editor editor, DataContext dataContext) {
  editor.getCaretModel().removeSecondaryCarets();
  int offset = editor.getDocument().getTextLength();
  if (editor instanceof EditorImpl && ((EditorImpl)editor).myUseNewRendering) {
    editor.getCaretModel().moveToLogicalPosition(editor.offsetToLogicalPosition(offset).leanForward(true));
  }
  else {
    editor.getCaretModel().moveToOffset(offset);
  }
  editor.getSelectionModel().removeSelection();

  ScrollingModel scrollingModel = editor.getScrollingModel();
  scrollingModel.disableAnimation();
  scrollingModel.scrollToCaret(ScrollType.CENTER);
  scrollingModel.enableAnimation();

  Project project = CommonDataKeys.PROJECT.getData(dataContext);
  if (project != null) {
    IdeDocumentHistory instance = IdeDocumentHistory.getInstance(project);
    if (instance != null) {
      instance.includeCurrentCommandAsNavigation();
    }
  }
}
 

import com.intellij.openapi.editor.impl.EditorImpl; //导入依赖的package包/类
private int visualLineStartOffset(int offset, boolean leanForward) {
  EditorImpl editor = myView.getEditor();
  int result = EditorUtil.getNotFoldedLineStartOffset(editor, offset);

  SoftWrapModelImpl softWrapModel = editor.getSoftWrapModel();
  List<? extends SoftWrap> softWraps = softWrapModel.getRegisteredSoftWraps();
  int currentOrPrevWrapIndex = softWrapModel.getSoftWrapIndex(offset);
  SoftWrap currentOrPrevWrap;
  if (currentOrPrevWrapIndex < 0) {
    currentOrPrevWrapIndex = - currentOrPrevWrapIndex - 2;
    currentOrPrevWrap = currentOrPrevWrapIndex < 0 || currentOrPrevWrapIndex >= softWraps.size() ? null :
                        softWraps.get(currentOrPrevWrapIndex);
  }
  else {
    currentOrPrevWrap = leanForward ? softWraps.get(currentOrPrevWrapIndex) : null;
  }
  if (currentOrPrevWrap != null && currentOrPrevWrap.getStart() > result) {
    result = currentOrPrevWrap.getStart();
  }
  return result;
}
 

import com.intellij.openapi.editor.impl.EditorImpl; //导入依赖的package包/类
public EditorView(EditorImpl editor) {
  myFontRenderContext = createFontRenderContext();
  myEditor = editor;
  myDocument = editor.getDocument();
  
  myPainter = new EditorPainter(this);
  myMapper = new EditorCoordinateMapper(this);
  mySizeManager = new EditorSizeManager(this);
  myTextLayoutCache = new TextLayoutCache(this);
  myLogicalPositionCache = new LogicalPositionCache(this);
  myTabFragment = new TabFragment(this);
  
  Disposer.register(this, myLogicalPositionCache);
  Disposer.register(this, myTextLayoutCache);
  Disposer.register(this, mySizeManager);
}
 

import com.intellij.openapi.editor.impl.EditorImpl; //导入依赖的package包/类
private IncrementalCacheUpdateEvent(@NotNull Document document, int startOffset, int oldEndOffset, int newEndOffset, 
                                    @NotNull CachingSoftWrapDataMapper mapper, @NotNull EditorImpl editor) {
  myStartOffset = editor.myUseNewRendering ? editor.visualLineStartOffset(editor.offsetToVisualLine(startOffset) - 1) : 
                  mapper.getPreviousVisualLineStartOffset(startOffset);
  myMandatoryEndOffset = newEndOffset;
  myLengthDiff = newEndOffset - oldEndOffset;
  myStartLogicalPosition = editor.myUseNewRendering ? editor.offsetToLogicalPosition(myStartOffset) : 
                           mapper.offsetToLogicalPosition(myStartOffset);
  if (editor.myUseNewRendering) {
    myStartVisualPosition = editor.logicalToVisualPosition(myStartLogicalPosition);
  }
  else {
    LOG.assertTrue(myStartLogicalPosition.visualPositionAware);
    myStartVisualPosition = myStartLogicalPosition.toVisualPosition();
  }
  myOldEndLogicalLine = document.getLineNumber(oldEndOffset);
}
 

import com.intellij.openapi.editor.impl.EditorImpl; //导入依赖的package包/类
/**
 * Every soft wrap implies that multiple visual positions correspond to the same document offset. We can classify
 * such positions by the following criteria:
 * <pre>
 * <ul>
 *   <li>positions from visual line with soft wrap start;</li>
 *   <li>positions from visual line with soft wrap end;</li>
 * </ul>
 * </pre>
 * <p/>
 * This method allows to answer if caret offset of the given editor points to soft wrap and visual caret position
 * belongs to the visual line where soft wrap end is located.
 *
 * @param editor    target editor
 * @return          <code>true</code> if caret offset of the given editor points to visual position that belongs to
 *                  visual line where soft wrap end is located
 */
public static boolean isCaretAfterSoftWrap(CaretImpl caret) {
  if (!caret.isUpToDate()) {
    return false;
  }
  EditorImpl editor = caret.getEditor();
  SoftWrapModel softWrapModel = editor.getSoftWrapModel();
  int offset = caret.getOffset();
  SoftWrap softWrap = softWrapModel.getSoftWrap(offset);
  if (softWrap == null) {
    return false;
  }

  if (editor.myUseNewRendering) {
    VisualPosition afterWrapPosition = editor.offsetToVisualPosition(offset, false, false);
    VisualPosition caretPosition = caret.getVisualPosition();
    return caretPosition.line == afterWrapPosition.line && caretPosition.column <= afterWrapPosition.column;
  }
  else {
    return editor.offsetToVisualLine(offset) == caret.getVisualPosition().line;
  }
}
 

import com.intellij.openapi.editor.impl.EditorImpl; //导入依赖的package包/类
@Override
public Dimension getPreferredSize() {
  if (myPreferredSize == null) {
    int maxLineLength = 0;
    int linesCount = 0;

    for (LineTokenizer lt = new LineTokenizer(myRawText); !lt.atEnd(); lt.advance()) {
      maxLineLength = Math.max(maxLineLength, lt.getLength());
      linesCount++;
    }

    FontMetrics fontMetrics = ((EditorImpl)getEditor()).getFontMetrics(myTextAttributes != null ? myTextAttributes.getFontType() : Font.PLAIN);
    int preferredHeight = getEditor().getLineHeight() * Math.max(1, linesCount);
    int preferredWidth = fontMetrics.charWidth('m') * maxLineLength;

    Insets insets = getInsets();
    if (insets != null) {
      preferredHeight += insets.top + insets.bottom;
      preferredWidth += insets.left + insets.right;
    }

    myPreferredSize = new Dimension(preferredWidth, preferredHeight);
  }
  return myPreferredSize;
}
 

import com.intellij.openapi.editor.impl.EditorImpl; //导入依赖的package包/类
public void testSoftWrapsRecalculationOnTabWidthChange() throws IOException {
  // Inspired by IDEA-78616 - the point is to recalculate soft wraps when tab width is changed.
  String text = 
    "\t<caret> my text";

  // Build soft wraps cache.
  init(40, text);
  
  VisualPosition caretPositionBefore = getEditor().getCaretModel().getVisualPosition();

  // Change tab size.
  final CommonCodeStyleSettings.IndentOptions indentOptions = getCurrentCodeStyleSettings().getIndentOptions();
  assertNotNull(indentOptions);
  indentOptions.TAB_SIZE++;

  ((EditorImpl)getEditor()).reinitSettings();
  assertEquals(
    new VisualPosition(caretPositionBefore.line, caretPositionBefore.column + 1),
    getEditor().getCaretModel().getVisualPosition()
  );
}
 

import com.intellij.openapi.editor.impl.EditorImpl; //导入依赖的package包/类
static void setOrRefreshErrorStripeRenderer(@NotNull EditorMarkupModel editorMarkupModel,
                                            @NotNull Project project,
                                            @NotNull Document document,
                                            PsiFile file) {
  ApplicationManager.getApplication().assertIsDispatchThread();
  if (!editorMarkupModel.isErrorStripeVisible() || !DaemonCodeAnalyzer.getInstance(project).isHighlightingAvailable(file)) {
    return;
  }
  ErrorStripeRenderer renderer = editorMarkupModel.getErrorStripeRenderer();
  if (renderer instanceof TrafficLightRenderer) {
    TrafficLightRenderer tlr = (TrafficLightRenderer)renderer;
    tlr.refresh();
    ((EditorMarkupModelImpl)editorMarkupModel).repaintVerticalScrollBar();
    if (tlr.myFile == null || tlr.myFile.isValid()) return;
    Disposer.dispose(tlr);
  }
  EditorImpl editor = (EditorImpl)editorMarkupModel.getEditor();

  if (!editor.isDisposed()) {
    renderer = new TrafficLightRenderer(project, document, file);
    Disposer.register(editor.getDisposable(), (Disposable)renderer);
    editorMarkupModel.setErrorStripeRenderer(renderer);
  }
}
 

import com.intellij.openapi.editor.impl.EditorImpl; //导入依赖的package包/类
public ConsoleGutterComponent(@NotNull Editor editor, @NotNull GutterContentProvider gutterContentProvider, boolean atLineStart) {
  this.editor = (EditorImpl)editor;
  this.gutterContentProvider = gutterContentProvider;
  this.atLineStart = atLineStart;

  if (atLineStart) {
    setOpaque(gutterContentProvider.getLineStartGutterOverlap(editor) == 0);
  }
  else {
    addListeners();
    setOpaque(false);
  }

  int spaceWidth = EditorUtil.getSpaceWidth(Font.PLAIN, editor);
  // at line start: icon/one-char symbol + space
  gap = atLineStart ? spaceWidth * GutterContentProvider.MAX_LINE_END_GUTTER_WIDTH_IN_CHAR : spaceWidth;
  maxContentWidth = atLineStart ? gap : 0;
}
 

import com.intellij.openapi.editor.impl.EditorImpl; //导入依赖的package包/类
@NotNull
public static Editor getInjectedEditorForInjectedFile(@NotNull Editor hostEditor, @NotNull Caret hostCaret, @Nullable final PsiFile injectedFile) {
  if (injectedFile == null || hostEditor instanceof EditorWindow || hostEditor.isDisposed()) return hostEditor;
  Project project = hostEditor.getProject();
  if (project == null) project = injectedFile.getProject();
  Document document = PsiDocumentManager.getInstance(project).getDocument(injectedFile);
  if (!(document instanceof DocumentWindowImpl)) return hostEditor;
  DocumentWindowImpl documentWindow = (DocumentWindowImpl)document;
  if (hostCaret.hasSelection()) {
    int selstart = hostCaret.getSelectionStart();
    if (selstart != -1) {
      int selend = Math.max(selstart, hostCaret.getSelectionEnd());
      if (!documentWindow.containsRange(selstart, selend)) {
        // selection spreads out the injected editor range
        return hostEditor;
      }
    }
  }
  if (!documentWindow.isValid()) {
    return hostEditor; // since the moment we got hold of injectedFile and this moment call, document may have been dirtied
  }
  return EditorWindowImpl.create(documentWindow, (EditorImpl)hostEditor, injectedFile);
}
 

import com.intellij.openapi.editor.impl.EditorImpl; //导入依赖的package包/类
public static Editor openEditorFor(@NotNull PsiFile file, @NotNull Project project) {
  Document document = PsiDocumentManager.getInstance(project).getDocument(file);
  // may return editor injected in current selection in the host editor, not for the file passed as argument
  VirtualFile virtualFile = file.getVirtualFile();
  if (virtualFile == null) {
    return null;
  }
  if (virtualFile instanceof VirtualFileWindow) {
    virtualFile = ((VirtualFileWindow)virtualFile).getDelegate();
  }
  Editor editor = FileEditorManager.getInstance(project).openTextEditor(new OpenFileDescriptor(project, virtualFile, -1), false);
  if (editor == null || editor instanceof EditorWindow || editor.isDisposed()) return editor;
  if (document instanceof DocumentWindowImpl) {
    return EditorWindowImpl.create((DocumentWindowImpl)document, (EditorImpl)editor, file);
  }
  return editor;
}
 

import com.intellij.openapi.editor.impl.EditorImpl; //导入依赖的package包/类
public static Editor create(@NotNull final DocumentWindowImpl documentRange, @NotNull final EditorImpl editor, @NotNull final PsiFile injectedFile) {
  assert documentRange.isValid();
  assert injectedFile.isValid();
  EditorWindowImpl window;
  synchronized (allEditors) {
    for (EditorWindowImpl editorWindow : allEditors) {
      if (editorWindow.getDocument() == documentRange && editorWindow.getDelegate() == editor) {
        editorWindow.myInjectedFile = injectedFile;
        if (editorWindow.isValid()) {
          return editorWindow;
        }
      }
      if (editorWindow.getDocument().areRangesEqual(documentRange)) {
        //int i = 0;
      }
    }
    window = new EditorWindowImpl(documentRange, editor, injectedFile, documentRange.isOneLine());
    allEditors.add(window);
  }
  assert window.isValid();
  return window;
}