Java EditorUtil类代码示例

import com.intellij.openapi.editor.ex.util.EditorUtil; //导入依赖的package包/类
public void testSoftWrapsRecalculationInASpecificCase() throws Exception {
  configureFromFileText(getTestName(false) + ".java",
                        "<selection>class Foo {\n" +
                        "\[email protected]\n" +
                        "\tpublic boolean equals(Object other) {\n" +
                        "\t\treturn this == other;\n" +
                        "\t}\n" +
                        "}</selection>");
  CodeFoldingManager.getInstance(ourProject).buildInitialFoldings(myEditor);
  EditorTestUtil.configureSoftWraps(myEditor, 232, 7); // wrap after 32 characters

  // verify initial state
  assertEquals(4, EditorUtil.getTabSize(myEditor));
  assertEquals("[FoldRegion +(59:64), placeholder=' { ', FoldRegion +(85:88), placeholder=' }']", myEditor.getFoldingModel().toString());
  verifySoftWrapPositions(52, 85);
  
  Document document = myEditor.getDocument();
  for (int i = document.getLineCount() - 1; i >= 0; i--) {
    document.insertString(document.getLineStartOffset(i), "//");
  }

  verifySoftWrapPositions(58, 93);
}
 

import com.intellij.openapi.editor.ex.util.EditorUtil; //导入依赖的package包/类
private void paintAfterLineEndBackgroundSegments(@NotNull Graphics g,
                                                 @NotNull IterationState iterationState,
                                                 @NotNull Point position,
                                                 @NotNull Color defaultBackground,
                                                 int lineHeight) {
  while (iterationState.hasPastLineEndBackgroundSegment()) {
    TextAttributes backgroundAttributes = iterationState.getPastLineEndBackgroundAttributes();
    int width = EditorUtil.getSpaceWidth(backgroundAttributes.getFontType(), this) * iterationState.getPastLineEndBackgroundSegmentWidth();
    Color color = getBackgroundColor(backgroundAttributes);
    if (color != null && !color.equals(defaultBackground)) {
      g.setColor(color);
      g.fillRect(position.x, position.y, width, lineHeight);
    }
    position.x += width;
    iterationState.advanceToNextPastLineEndBackgroundSegment();
  }
}
 

import com.intellij.openapi.editor.ex.util.EditorUtil; //导入依赖的package包/类
private int getTextSegmentWidth(@NotNull CharSequence text,
                                int start,
                                int end,
                                int xStart,
                                @JdkConstants.FontStyle int fontType,
                                @NotNull Rectangle clip) {
  int x = xStart;

  for (int i = start; i < end && xStart < clip.x + clip.width; i++) {
    char c = text.charAt(i);
    if (c == '\t') {
      x = EditorUtil.nextTabStop(x, this);
    }
    else {
      x += EditorUtil.charWidth(c, fontType, this);
    }
    if (x > clip.x + clip.width) {
      break;
    }
  }
  return x - xStart;
}
 

import com.intellij.openapi.editor.ex.util.EditorUtil; //导入依赖的package包/类
public Dimension getPreferredSize() {
  if (myUseNewRendering) return myView.getPreferredSize();
  if (ourIsUnitTestMode && getUserData(DO_DOCUMENT_UPDATE_TEST) == null) {
    return new Dimension(1, 1);
  }

  final Dimension draft = getSizeWithoutCaret();
  final int additionalSpace = shouldRespectAdditionalColumns()
                              ? mySettings.getAdditionalColumnsCount() * EditorUtil.getSpaceWidth(Font.PLAIN, this)
                              : 0;

  if (!myDocument.isInBulkUpdate()) {
    for (Caret caret : myCaretModel.getAllCarets()) {
      if (caret.isUpToDate()) {
        int caretX = visualPositionToXY(caret.getVisualPosition()).x;
        draft.width = Math.max(caretX, draft.width);
      }
    }
  }
  draft.width += additionalSpace;
  return draft;
}
 

import com.intellij.openapi.editor.ex.util.EditorUtil; //导入依赖的package包/类
@Override
public void setPrefixTextAndAttributes(@Nullable String prefixText, @Nullable TextAttributes attributes) {
  myPrefixText = prefixText == null ? null : prefixText.toCharArray();
  myPrefixAttributes = attributes;
  myPrefixWidthInPixels = 0;
  if (myPrefixText != null) {
    for (char c : myPrefixText) {
      LOG.assertTrue(myPrefixAttributes != null);
      if (myPrefixAttributes != null) {
        myPrefixWidthInPixels += EditorUtil.charWidth(c, myPrefixAttributes.getFontType(), this);
      }
    }
  }
  mySoftWrapModel.recalculate();
  if (myUseNewRendering) myView.setPrefix(prefixText, attributes);
}
 

import com.intellij.openapi.editor.ex.util.EditorUtil; //导入依赖的package包/类
/**
 * Called on editor settings change. Current model is expected to drop all cached information about the settings if any.
 */
public void reinitSettings() {
  boolean softWrapsUsedBefore = myUseSoftWraps;
  myUseSoftWraps = areSoftWrapsEnabledInEditor();

  int tabWidthBefore = myTabWidth;
  myTabWidth = EditorUtil.getTabSize(myEditor);

  boolean fontsChanged = false;
  if (!myFontPreferences.equals(myEditor.getColorsScheme().getFontPreferences())
      && myEditorTextRepresentationHelper instanceof DefaultEditorTextRepresentationHelper) {
    fontsChanged = true;
    myEditor.getColorsScheme().getFontPreferences().copyTo(myFontPreferences);
    ((DefaultEditorTextRepresentationHelper)myEditorTextRepresentationHelper).clearSymbolWidthCache();
    myPainter.reinit();
  }
  
  if ((myUseSoftWraps ^ softWrapsUsedBefore) || (tabWidthBefore >= 0 && myTabWidth != tabWidthBefore) || fontsChanged) {
    myApplianceManager.reset();
    myDeferredFoldRegions.clear();
    myStorage.removeAll();
    myEditor.getScrollingModel().scrollToCaret(ScrollType.CENTER);
  }
}
 

import com.intellij.openapi.editor.ex.util.EditorUtil; //导入依赖的package包/类
@Override
public int getMaxWidthInRange(int startOffset, int endOffset) {
  if (myUseNewRendering) return myView.getMaxWidthInRange(startOffset, endOffset);
  int width = 0;
  int start = offsetToVisualLine(startOffset);
  int end = offsetToVisualLine(endOffset);

  for (int i = start; i <= end; i++) {
    int lastColumn = EditorUtil.getLastVisualLineColumnNumber(this, i) + 1;
    int lineWidth = visualPositionToXY(new VisualPosition(i, lastColumn)).x;

    if (lineWidth > width) {
      width = lineWidth;
    }
  }

  return width;
}
 

import com.intellij.openapi.editor.ex.util.EditorUtil; //导入依赖的package包/类
private void paintAfterLineEndBackgroundSegments(@NotNull Graphics g,
                                                 @NotNull IterationState iterationState,
                                                 @NotNull Point position,
                                                 @NotNull Color defaultBackground,
                                                 int lineHeight) {
  while (iterationState.hasPastLineEndBackgroundSegment()) {
    TextAttributes backgroundAttributes = iterationState.getPastLineEndBackgroundAttributes();
    int width =
      EditorUtil.getSpaceWidth(backgroundAttributes.getFontType(), this) * iterationState.getPastLineEndBackgroundSegmentWidth();
    Color color = getBackgroundColor(backgroundAttributes);
    if (color != null && !color.equals(defaultBackground)) {
      g.setColor(color);
      g.fillRect(position.x, position.y, width, lineHeight);
    }
    position.x += width;
    iterationState.advanceToNextPastLineEndBackgroundSegment();
  }
}
 

import com.intellij.openapi.editor.ex.util.EditorUtil; //导入依赖的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.ex.util.EditorUtil; //导入依赖的package包/类
private void drawCharsCached(@NotNull Graphics g,
                             CharSequence data,
                             int start,
                             int end,
                             int x,
                             int y,
                             @JdkConstants.FontStyle int fontType,
                             Color color,
                             boolean drawWhitespace) {
  FontInfo fnt = EditorUtil.fontForChar(data.charAt(start), fontType, this);
  if (myLastCache != null && spacesOnly(data, start, end) && fnt.charWidth(' ') == myLastCache.spaceWidth) {
    // we don't care about font if we only need to paint spaces and space width matches
    myLastCache.addContent(g, data, start, end, x, y, null, drawWhitespace);
  }
  else {
    drawCharsCached(g, data, start, end, x, y, fnt, color, drawWhitespace);
  }
}
 

import com.intellij.openapi.editor.ex.util.EditorUtil; //导入依赖的package包/类
private static void tweakEditorAndFireUpdateUI(UISettings settings, boolean inPresentation) {
  EditorColorsScheme globalScheme = EditorColorsManager.getInstance().getGlobalScheme();
  int fontSize = inPresentation ? settings.PRESENTATION_MODE_FONT_SIZE : globalScheme.getEditorFontSize();
  if (inPresentation) {
    ourSavedConsoleFontSize = globalScheme.getConsoleFontSize();
    globalScheme.setConsoleFontSize(fontSize);
  }
  else {
    globalScheme.setConsoleFontSize(ourSavedConsoleFontSize);
  }
  for (Editor editor : EditorFactory.getInstance().getAllEditors()) {
    if (editor instanceof EditorEx) {
      ((EditorEx)editor).setFontSize(fontSize);
    }
  }
  UISettings.getInstance().fireUISettingsChanged();
  LafManager.getInstance().updateUI();
  EditorUtil.reinitSettings();
}
 

import com.intellij.openapi.editor.ex.util.EditorUtil; //导入依赖的package包/类
@Override
public void actionPerformed(AnActionEvent e) {
  final Project project = e.getProject();
  final Editor editor = CommonDataKeys.EDITOR.getData(e.getDataContext());
  final VirtualFile virtualFile = CommonDataKeys.VIRTUAL_FILE.getData(e.getDataContext());
  if (project == null || editor == null || virtualFile == null) return;

  final Document document = editor.getDocument();
  final TextRange selectedRange = EditorUtil.getSelectionInAnyMode(editor);
  final String command = (selectedRange.isEmpty() ? document.getText() : document.getText(selectedRange));

  final GroovyConsole existingConsole = virtualFile.getUserData(GroovyConsole.GROOVY_CONSOLE);
  if (existingConsole == null) {
    GroovyConsole.getOrCreateConsole(project, virtualFile, new Consumer<GroovyConsole>() {
      @Override
      public void consume(GroovyConsole console) {
        console.execute(command);
      }
    });
  }
  else {
    existingConsole.execute(command);
  }
}
 

import com.intellij.openapi.editor.ex.util.EditorUtil; //导入依赖的package包/类
private void checkResultByFile(@NonNls @NotNull String expectedFile,
                               @NotNull PsiFile originalFile,
                               boolean stripTrailingSpaces) throws IOException {
  if (!stripTrailingSpaces) {
    EditorUtil.fillVirtualSpaceUntilCaret(myEditor);
  }
  PsiDocumentManager.getInstance(getProject()).commitAllDocuments();

  final String fileText = originalFile.getText();
  final String path = getTestDataPath() + "/" + expectedFile;

  /*final VirtualFile result = LocalFileSystem.getInstance().findFileByPath(path);
  final int caret = myEditor.getCaretModel().getOffset();
  final String newText = myFile == originalFile ? fileText.substring(0, caret) + "<caret>" + fileText.substring(caret) : fileText;
  VfsUtil.saveText(result, newText);*/

  VirtualFile virtualFile = originalFile.getVirtualFile();
  String charset = virtualFile == null? null : virtualFile.getCharset().name();
  checkResult(expectedFile, stripTrailingSpaces, SelectionAndCaretMarkupLoader.fromFile(path, charset), fileText);

}
 

import com.intellij.openapi.editor.ex.util.EditorUtil; //导入依赖的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.ex.util.EditorUtil; //导入依赖的package包/类
public static void doSelectLineAtCaret(Editor editor) {
  int lineNumber = editor.getCaretModel().getLogicalPosition().line;
  Document document = editor.getDocument();
  if (lineNumber >= document.getLineCount()) {
    return;
  }

  Pair<LogicalPosition, LogicalPosition> lines = EditorUtil.calcCaretLineRange(editor);
  LogicalPosition lineStart = lines.first;
  LogicalPosition nextLineStart = lines.second;

  int start = editor.logicalPositionToOffset(lineStart);
  int end = editor.logicalPositionToOffset(nextLineStart);

  //myEditor.getCaretModel().moveToOffset(start);
  editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
  editor.getSelectionModel().removeSelection();
  editor.getSelectionModel().setSelection(start, end);
}