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);
}
 

import com.intellij.openapi.editor.ex.util.EditorUtil; //导入依赖的package包/类
private void calcAnnotationExtraSize() {
  myTextAnnotationExtraSize = 0;
  if (!myEditor.isInDistractionFreeMode() || isMirrored()) return;

  Window frame = SwingUtilities.getWindowAncestor(myEditor.getComponent());
  if (frame == null) return;

  EditorSettings settings = myEditor.getSettings();
  int rightMargin = settings.getRightMargin(myEditor.getProject());
  if (rightMargin <= 0) return;

  JComponent editorComponent = myEditor.getComponent();
  RelativePoint point = new RelativePoint(editorComponent, new Point(0, 0));
  Point editorLocationInWindow = point.getPoint(frame);

  int editorLocationX = (int)editorLocationInWindow.getX();
  int rightMarginX = rightMargin * EditorUtil.getSpaceWidth(Font.PLAIN, myEditor) + editorLocationX;

  int width = editorLocationX + editorComponent.getWidth();
  if (rightMarginX < width && editorLocationX < width - rightMarginX) {
    int centeredSize = (width - rightMarginX - editorLocationX) / 2 - (getLineMarkerAreaWidth() + getLineNumberAreaWidth());
    myTextAnnotationExtraSize = Math.max(0, centeredSize - myTextAnnotationGuttersSize);
  }
}
 

import com.intellij.openapi.editor.ex.util.EditorUtil; //导入依赖的package包/类
/**
 * Tries to find fonts that are capable to display all unicode symbols used by the current painter.
 */
@Override
public void reinit() {
  // We use dummy component here in order to being able to work with font metrics.
  JLabel component = new JLabel();

  myCanUse = true;
  for (Map.Entry<SoftWrapDrawingType, char[]> entry : mySymbols.entrySet()) {
    SoftWrapDrawingType type = entry.getKey();
    char c = entry.getValue()[0];
    FontInfo fontInfo = EditorUtil.fontForChar(c, Font.PLAIN, myEditor);
    if (!fontInfo.canDisplay(c)) {
      myCanUse = false;
      myFonts.put(type, null);
      myVGaps.put(type, null);
      myWidths[type.ordinal()] = 0;
    }
    else {
      myFonts.put(type, fontInfo);
      FontMetrics metrics = component.getFontMetrics(fontInfo.getFont());
      myWidths[type.ordinal()] = metrics.charWidth(c);
      int vGap = metrics.getDescent();
      myVGaps.put(type, vGap);
    }
  }
}
 

import com.intellij.openapi.editor.ex.util.EditorUtil; //导入依赖的package包/类
@Nullable
Font getFontAbleToDisplay(LookupElementPresentation p) {
  String sampleString = p.getItemText() + p.getTailText() + p.getTypeText();

  // assume a single font can display all lookup item chars
  Set<Font> fonts = ContainerUtil.newHashSet();
  for (int i = 0; i < sampleString.length(); i++) {
    fonts.add(EditorUtil.fontForChar(sampleString.charAt(i), Font.PLAIN, myLookup.getEditor()).getFont());
  }

  eachFont: for (Font font : fonts) {
    if (font.equals(myNormalFont)) continue;
    
    for (int i = 0; i < sampleString.length(); i++) {
      if (!font.canDisplay(sampleString.charAt(i))) {
        continue eachFont;
      }
    }
    return font;
  }
  return null;
}
 

import com.intellij.openapi.editor.ex.util.EditorUtil; //导入依赖的package包/类
@Override
  public void invoke(@NotNull Project project, final Editor editor, PsiFile file) {
    if (!FileModificationService.getInstance().prepareFileForWrite(file)) return;
    PsiReferenceExpression[] refs = CreateFromUsageUtils.collectExpressions(myRefExpr, PsiMember.class, PsiFile.class);
    PsiElement element = PsiTreeUtil.getParentOfType(myRefExpr, PsiMember.class, PsiFile.class);
    LookupElement[] items = collectItems();
    ReferenceNameExpression refExpr = new ReferenceNameExpression(items, myRefExpr.getReferenceName());

    TemplateBuilderImpl builder = new TemplateBuilderImpl(element);
    for (PsiReferenceExpression expr : refs) {
      if (!expr.equals(myRefExpr)) {
        builder.replaceElement(expr.getReferenceNameElement(), OTHER_VARIABLE_NAME, INPUT_VARIABLE_NAME, false);
      }
      else {
        builder.replaceElement(expr.getReferenceNameElement(), INPUT_VARIABLE_NAME, refExpr, true);
      }
    }

    final float proportion = EditorUtil.calcVerticalScrollProportion(editor);
    editor.getCaretModel().moveToOffset(element.getTextRange().getStartOffset());

    /*for (int i = refs.length - 1; i >= 0; i--) {
      TextRange range = refs[i].getReferenceNameElement().getTextRange();
      document.deleteString(range.getStartOffset(), range.getEndOffset());
    }
*/
    Template template = builder.buildInlineTemplate();
    editor.getCaretModel().moveToOffset(element.getTextRange().getStartOffset());

    TemplateManager.getInstance(project).startTemplate(editor, template);

    EditorUtil.setVerticalScrollProportion(editor, proportion);
  }
 

import com.intellij.openapi.editor.ex.util.EditorUtil; //导入依赖的package包/类
private void initTabPainter() {
  myTabPainter = new ArrowPainter(
    ColorProvider.byColorsScheme(myScheme, EditorColors.WHITESPACES_COLOR),
    new Computable.PredefinedValueComputable<Integer>(EditorUtil.getSpaceWidth(Font.PLAIN, this)),
    new Computable<Integer>() {
      @Override
      public Integer compute() {
        return getCharHeight();
      }
    }
  );
}