Java DocumentEx类代码示例

import com.intellij.openapi.editor.ex.DocumentEx; //导入依赖的package包/类
public void testMoveText() {
  PsiJavaFile file = (PsiJavaFile)configureByText(JavaFileType.INSTANCE, "class C1{}\nclass C2 {}");
  DocumentEx document = (DocumentEx)file.getViewProvider().getDocument();

  SmartPsiElementPointer<PsiClass> pointer1 =
    createPointer(file.getClasses()[0]);
  SmartPsiElementPointer<PsiClass> pointer2 =
    createPointer(file.getClasses()[1]);
  assertEquals("C1", pointer1.getElement().getName());
  assertEquals("C2", pointer2.getElement().getName());

  PlatformTestUtil.tryGcSoftlyReachableObjects();
  assertNull(((SmartPointerEx) pointer1).getCachedElement());
  assertNull(((SmartPointerEx) pointer2).getCachedElement());

  TextRange range = file.getClasses()[1].getTextRange();
  document.moveText(range.getStartOffset(), range.getEndOffset(), 0);

  System.out.println(pointer1.getRange());
  System.out.println(pointer2.getRange());

  PsiDocumentManager.getInstance(myProject).commitAllDocuments();

  assertEquals("C1", pointer1.getElement().getName());
  assertEquals("C2", pointer2.getElement().getName());
}
 

import com.intellij.openapi.editor.ex.DocumentEx; //导入依赖的package包/类
private boolean translatedViaDiff(DocumentEvent e, DocumentEventImpl event) {
  try {
    myLine = event.translateLineViaDiff(myLine);
  }
  catch (FilesTooBigForDiffException ignored) {
    return false;
  }
  if (myLine < 0 || myLine >= getDocument().getLineCount()) {
    invalidate(e);
  }
  else {
    DocumentEx document = getDocument();
    setIntervalStart(document.getLineStartOffset(myLine));
    setIntervalEnd(document.getLineEndOffset(myLine));
  }
  return true;
}
 

import com.intellij.openapi.editor.ex.DocumentEx; //导入依赖的package包/类
private void reinitDocumentIndentOptions() {
  if (myEditor == null) return;
  final Project project = myEditor.getProject();
  final DocumentEx document = myEditor.getDocument();

  if (project == null || project.isDisposed()) return;

  final PsiDocumentManager psiManager = PsiDocumentManager.getInstance(project);
  final PsiFile file = psiManager.getPsiFile(document);
  if (file == null) return;

  CodeStyleSettings settings = CodeStyleSettingsManager.getInstance(project).getCurrentSettings();
  CommonCodeStyleSettings.IndentOptions options = settings.getIndentOptionsByFile(file);

  if (CodeStyleSettings.isRecalculateForCommittedDocument(options)) {
    PsiDocumentManager.getInstance(project).performForCommittedDocument(document, new Runnable() {
      @Override
      public void run() {
        CodeStyleSettingsManager.updateDocumentIndentOptions(project, document);
      }
    });
  }
  else {
    CodeStyleSettingsManager.updateDocumentIndentOptions(project, document);
  }
}
 

import com.intellij.openapi.editor.ex.DocumentEx; //导入依赖的package包/类
/**
 * Updates state of the current context object in order to point to the end of the given collapsed fold region.
 * 
 * @param foldRegion    collapsed fold region to process
 */
private void advance(FoldRegion foldRegion, int placeHolderWidthInPixels) {
  lastFoldStartPosition = currentPosition.clone();
  lastFold = foldRegion;
  int visualLineBefore = currentPosition.visualLine;
  int logicalLineBefore = currentPosition.logicalLine;
  int logicalColumnBefore = currentPosition.logicalColumn;
  currentPosition.advance(foldRegion, -1);
  currentPosition.x += placeHolderWidthInPixels;
  int collapsedFoldingWidthInColumns = currentPosition.logicalColumn;
  if (currentPosition.logicalLine <= logicalLineBefore) {
    // Single-line fold region.
    collapsedFoldingWidthInColumns = currentPosition.logicalColumn - logicalColumnBefore;
  }
  else {
    final DocumentEx document = myEditor.getDocument();
    int endFoldLine = document.getLineNumber(foldRegion.getEndOffset());
    logicalLineData.endLineOffset = document.getLineEndOffset(endFoldLine);
  }
  notifyListenersOnFoldRegion(foldRegion, collapsedFoldingWidthInColumns, visualLineBefore);
  tokenStartOffset = myContext.currentPosition.offset;
  softWrapStartOffset = foldRegion.getEndOffset();
  lastFoldEndPosition = currentPosition.clone();
}
 

import com.intellij.openapi.editor.ex.DocumentEx; //导入依赖的package包/类
public void testSaveDocument_DoNotSaveIfModStampEqualsToFile() throws Exception {
  final VirtualFile file = createFile();
  final DocumentEx document = (DocumentEx)myDocumentManager.getDocument(file);
  assertNotNull(file.toString(), document);
  WriteCommandAction.runWriteCommandAction(myProject, new Runnable() {
    @Override
    public void run() {
      document.insertString(0, "zzz");
      document.setModificationStamp(file.getModificationStamp());
    }
  });

  getProject().getMessageBus().connect(getTestRootDisposable()).subscribe(AppTopics.FILE_DOCUMENT_SYNC, new FileDocumentManagerAdapter() {
    @Override
    public void beforeDocumentSaving(@NotNull Document documentToSave) {
      assertNotSame(document, documentToSave);
    }
  });

  myDocumentManager.saveDocument(document);
}
 

import com.intellij.openapi.editor.ex.DocumentEx; //导入依赖的package包/类
public void testSuccessiveBulkModeOperations() throws Exception {
  initText("some text");
  DocumentEx document = (DocumentEx)myEditor.getDocument();
  
  document.setInBulkUpdate(true);
  document.replaceString(4, 5, "-");
  document.setInBulkUpdate(false);
  
  myEditor.getCaretModel().moveToOffset(9);
  
  document.setInBulkUpdate(true);
  document.replaceString(4, 5, "+");
  document.setInBulkUpdate(false);
  
  checkResultByText("some+text<caret>");
}
 

import com.intellij.openapi.editor.ex.DocumentEx; //导入依赖的package包/类
private RangeMarkerImpl(@NotNull DocumentEx document, int start, int end, boolean register, boolean greedyToLeft, boolean greedyToRight) {
  if (start < 0) {
    throw new IllegalArgumentException("Wrong start: " + start+"; end="+end);
  }
  if (end > document.getTextLength()) {
    throw new IllegalArgumentException("Wrong end: " + end+ "; document length="+document.getTextLength()+"; start="+start);
  }
  if (start > end){
    throw new IllegalArgumentException("start > end: start=" + start+"; end="+end);
  }

  myDocument = document;
  myId = counter.next();
  if (register) {
    registerInTree(start, end, greedyToLeft, greedyToRight, 0);
  }
}
 

import com.intellij.openapi.editor.ex.DocumentEx; //导入依赖的package包/类
private void doSync(@NotNull final PsiTreeChangeEvent event, boolean force, @NotNull final DocSyncAction syncAction) {
  if (!toProcessPsiEvent()) return;
  final PsiFile psiFile = event.getFile();
  if (!(psiFile instanceof PsiFileEx) || !((PsiFileEx)psiFile).isContentsLoaded()) return;

  final DocumentEx document = getCachedDocument(psiFile, force);
  if (document == null) return;

  performAtomically(psiFile, new Runnable() {
    @Override
    public void run() {
      syncAction.syncDocument(document, (PsiTreeChangeEventImpl)event);
    }
  });

  final boolean insideTransaction = myTransactionsMap.containsKey(document);
  if (!insideTransaction) {
    document.setModificationStamp(psiFile.getViewProvider().getModificationStamp());
    if (LOG.isDebugEnabled()) {
      PsiDocumentManagerBase.checkConsistency(psiFile, document);
    }
  }

}
 

import com.intellij.openapi.editor.ex.DocumentEx; //导入依赖的package包/类
private static void doCommitTransaction(@NotNull Document document, @NotNull DocumentChangeTransaction documentChangeTransaction) {
  DocumentEx ex = (DocumentEx) document;
  ex.suppressGuardedExceptions();
  try {
    boolean isReadOnly = !document.isWritable();
    ex.setReadOnly(false);

    for (Map.Entry<TextRange, CharSequence> entry : documentChangeTransaction.myAffectedFragments.descendingMap().entrySet()) {
      ex.replaceString(entry.getKey().getStartOffset(), entry.getKey().getEndOffset(), entry.getValue());
    }

    ex.setReadOnly(isReadOnly);
  }
  finally {
    ex.unSuppressGuardedExceptions();
  }
}
 

import com.intellij.openapi.editor.ex.DocumentEx; //导入依赖的package包/类
@NotNull
public DocumentEx getLastCommittedDocument(@NotNull Document document) {
  if (document instanceof FrozenDocument) return (DocumentEx)document;

  if (document instanceof DocumentWindow) {
    DocumentWindow window = (DocumentWindow)document;
    Document delegate = window.getDelegate();
    if (delegate instanceof FrozenDocument) return (DocumentEx)window;

    UncommittedInfo info = myUncommittedInfos.get(delegate);
    DocumentWindow answer = info == null ? null : info.myFrozenWindows.get(document);
    if (answer == null) answer = freezeWindow(window);
    if (info != null) answer = ConcurrencyUtil.cacheOrGet(info.myFrozenWindows, window, answer);
    return (DocumentEx)answer;
  }

  assert document instanceof DocumentImpl;
  UncommittedInfo info = myUncommittedInfos.get(document);
  return info != null ? info.myFrozen : ((DocumentImpl)document).freeze();
}
 

import com.intellij.openapi.editor.ex.DocumentEx; //导入依赖的package包/类
private static Runnable rememberDocumentState(final Editor _editor) {
  final Editor editor = InjectedLanguageUtil.getTopLevelEditor(_editor);
  final String documentText = editor.getDocument().getText();
  final int caret = editor.getCaretModel().getOffset();
  final int selStart = editor.getSelectionModel().getSelectionStart();
  final int selEnd = editor.getSelectionModel().getSelectionEnd();

  final int vOffset = editor.getScrollingModel().getVerticalScrollOffset();
  final int hOffset = editor.getScrollingModel().getHorizontalScrollOffset();

  return new Runnable() {
    @Override
    public void run() {
      DocumentEx document = (DocumentEx) editor.getDocument();

      document.replaceString(0, document.getTextLength(), documentText);
      editor.getCaretModel().moveToOffset(caret);
      editor.getSelectionModel().setSelection(selStart, selEnd);

      editor.getScrollingModel().scrollHorizontally(hOffset);
      editor.getScrollingModel().scrollVertically(vOffset);
    }
  };
}
 

import com.intellij.openapi.editor.ex.DocumentEx; //导入依赖的package包/类
private void updateStatus() {
  Editor editor = FileEditorManager.getInstance(myProject).getSelectedTextEditor();
  if (editor == null || !editor.getContentComponent().hasFocus()){
    return;
  }

  final Document document = editor.getDocument();
  if (document instanceof DocumentEx && ((DocumentEx)document).isInBulkUpdate()) return;

  int offset = editor.getCaretModel().getOffset();
  DaemonCodeAnalyzer codeAnalyzer = DaemonCodeAnalyzer.getInstance(myProject);
  HighlightInfo info = ((DaemonCodeAnalyzerImpl)codeAnalyzer).findHighlightByOffset(document, offset, false, HighlightSeverity.WARNING);
  String text = info != null && info.getDescription() != null ? info.getDescription() : "";

  StatusBar statusBar = WindowManager.getInstance().getStatusBar(editor.getContentComponent(), myProject);
  if (statusBar != null && !text.equals(statusBar.getInfo())) {
    statusBar.setInfo(text, "updater");
  }
}
 

import com.intellij.openapi.editor.ex.DocumentEx; //导入依赖的package包/类
@Override
public void documentChanged(DocumentEvent event) {
  DocumentEx document = getDocument();
  if (document.isInBulkUpdate()) {
    return;
  }

  if (document.getTextLength() > 0) {
    addLineSeparatorPainterIfNeed();
    int startDocLine = document.getLineNumber(event.getOffset());
    int endDocLine = document.getLineNumber(event.getOffset() + event.getNewLength());
    if (event.getOldLength() > event.getNewLength() || startDocLine != endDocLine || StringUtil.indexOf(event.getOldFragment(), '\n') != -1) {
      updateGutterSize(startDocLine, endDocLine);
    }
  }
  else if (event.getOldLength() > 0) {
    documentCleared();
  }
}
 

import com.intellij.openapi.editor.ex.DocumentEx; //导入依赖的package包/类
@Override
public CachedValueProvider.Result<MultiHostRegistrarImpl> compute(PsiElement element) {
  PsiFile hostPsiFile = element.getContainingFile();
  if (hostPsiFile == null) return null;
  FileViewProvider viewProvider = hostPsiFile.getViewProvider();
  final DocumentEx hostDocument = (DocumentEx)viewProvider.getDocument();
  if (hostDocument == null) return null;

  PsiManager psiManager = viewProvider.getManager();
  final Project project = psiManager.getProject();
  InjectedLanguageManagerImpl injectedManager = InjectedLanguageManagerImpl.getInstanceImpl(project);

  final MultiHostRegistrarImpl result = doCompute(element, injectedManager, project, hostPsiFile);

  return CachedValueProvider.Result.create(result, PsiModificationTracker.MODIFICATION_COUNT, hostDocument);
}
 

import com.intellij.openapi.editor.ex.DocumentEx; //导入依赖的package包/类
@Override
protected void setDone(boolean done) {
  super.setDone(done);

  if (myResetBulkUpdateState) {
    DocumentEx document = getAffectedDocument(myModel);
    if (document != null) {
      document.setInBulkUpdate(false);
      myResetBulkUpdateState = false;
    }
  }

  if (done) {
    myModel.commitChanges();
  }
}