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

import com.intellij.openapi.editor.ex.DocumentEx; //导入依赖的package包/类
protected void updateRawHtmlText(final String htmlTxt) {
    final DocumentEx myDocument = myTextViewer.getDocument();

    if (project.isDisposed()) return;

    ApplicationManager.getApplication().runWriteAction(new Runnable() {
        @Override
        public void run() {
            if (project.isDisposed()) return;

            CommandProcessor.getInstance().executeCommand(project, new Runnable() {
                @Override
                public void run() {
                    if (project.isDisposed()) return;

                    myDocument.replaceString(0, myDocument.getTextLength(), htmlTxt);
                    final CaretModel caretModel = myTextViewer.getCaretModel();
                    if (caretModel.getOffset() >= myDocument.getTextLength()) {
                        caretModel.moveToOffset(myDocument.getTextLength());
                    }
                }
            }, null, null, UndoConfirmationPolicy.DEFAULT, myDocument);
        }
    });
}
 

import com.intellij.openapi.editor.ex.DocumentEx; //导入依赖的package包/类
public static SelectionDescription createSelection(final Editor editor, final int lineIndex) {
  return new SelectionDescription(editor) {
    public void select() {
      if(myIsActive) return;
      myIsActive = true;
      DocumentEx doc = (DocumentEx)editor.getDocument();
      editor.getSelectionModel().setSelection(
        doc.getLineStartOffset(lineIndex),
        doc.getLineEndOffset(lineIndex) + doc.getLineSeparatorLength(lineIndex)
      );
    }

    public void remove() {
      if(!myIsActive) return;
      myIsActive = false;
      myEditor.getSelectionModel().removeSelection();
    }
  };
}
 

import com.intellij.openapi.editor.ex.DocumentEx; //导入依赖的package包/类
public EditorChangeAction(DocumentEx document,
                          int offset,
                          CharSequence oldString,
                          CharSequence newString,
                          long oldTimeStamp) {
  super(document);

  Charset charset = EncodingManager.getInstance().getEncoding(FileDocumentManager.getInstance().getFile(document), false);
  myCharset = charset == null ? Charset.defaultCharset() : charset;

  myOffset = offset;
  myOldString = oldString == null ? "" : compressCharSequence(oldString, myCharset);
  myNewString = newString == null ? "" : compressCharSequence(newString, myCharset);
  myOldTimeStamp = oldTimeStamp;
  myNewTimeStamp = document.getModificationStamp();
}
 

import com.intellij.openapi.editor.ex.DocumentEx; //导入依赖的package包/类
@Override
public HighlighterIterator createIterator(int startOffset) {
  synchronized (this) {
    final Document document = getDocument();
    if(document instanceof DocumentEx && ((DocumentEx)document).isInBulkUpdate()) {
      ((DocumentEx)document).setInBulkUpdate(false); // bulk mode failed
    }

    if (mySegments.getSegmentCount() == 0 && document != null && document.getTextLength() > 0) {
      // bulk mode was reset
      doSetText(document.getCharsSequence());
    }

    final int latestValidOffset = mySegments.getLastValidOffset();
    return new HighlighterIteratorImpl(startOffset <= latestValidOffset ? startOffset : latestValidOffset);
  }
}
 

import com.intellij.openapi.editor.ex.DocumentEx; //导入依赖的package包/类
RangeHighlighterImpl(@NotNull MarkupModel model,
                     int start,
                     int end,
                     int layer,
                     @NotNull HighlighterTargetArea target,
                     TextAttributes textAttributes, boolean greedyToLeft, boolean greedyToRight) {
  super((DocumentEx)model.getDocument(), start, end,false);

  data = new RangeHighlighterData(model, target, textAttributes) {
    @NotNull
    @Override
    public RangeHighlighterEx getRangeHighlighter() {
      return RangeHighlighterImpl.this;
    }
  };

  registerInTree(start, end, greedyToLeft, greedyToRight, layer);
}