import com.intellij.openapi.command.undo.UndoManager; //导入依赖的package包/类
@Override
public boolean importClass(PsiClass aClass) {
  final String className = aClass.getName();
  final String qName = aClass.getQualifiedName();
  if (qName == null) return false;
  //if (!myPseudoImports.containsKey(className)){
  myPseudoImports.put(className, qName);
  myManager.beforeChange(false); // to clear resolve caches!
  if (isPhysical()) {
    final Project project = myManager.getProject();
    final Document document = PsiDocumentManager.getInstance(project).getDocument(this);
    UndoManager.getInstance(project).undoableActionPerformed(new ImportClassUndoableAction(className, qName, document, myPseudoImports));
  }
  return true;
  //}
  //else{
  //  return false;
  //}
}
 

import com.intellij.openapi.command.undo.UndoManager; //导入依赖的package包/类
@Override
public void handleQualifiedNameChange(@NotNull final PsiPackage psiPackage, @NotNull final String newQualifiedName) {
  ApplicationManager.getApplication().assertWriteAccessAllowed();
  final String oldQualifedName = psiPackage.getQualifiedName();
  final boolean anyChanged = changePackagePrefixes(psiPackage, oldQualifedName, newQualifiedName);
  if (anyChanged) {
    UndoManager.getInstance(psiPackage.getProject()).undoableActionPerformed(new GlobalUndoableAction() {
      @Override
      public void undo() {
        changePackagePrefixes(psiPackage, newQualifiedName, oldQualifedName);
      }

      @Override
      public void redo() {
        changePackagePrefixes(psiPackage, oldQualifedName, newQualifiedName);
      }
    });
  }
}
 

import com.intellij.openapi.command.undo.UndoManager; //导入依赖的package包/类
public void testAutoImportWorks() throws Throwable {
  @NonNls final String text = "class S { JFrame x; <caret> }";
  configureByText(StdFileTypes.JAVA, text);
  ((UndoManagerImpl)UndoManager.getInstance(getProject())).flushCurrentCommandMerger();
  ((UndoManagerImpl)UndoManager.getInstance(getProject())).clearUndoRedoQueueInTests(getFile().getVirtualFile());
  assertFalse(DaemonListeners.canChangeFileSilently(getFile()));


  doHighlighting();
  assertFalse(DaemonListeners.canChangeFileSilently(getFile()));

  type(" ");
  assertTrue(DaemonListeners.canChangeFileSilently(getFile()));

  undo();

  assertFalse(DaemonListeners.canChangeFileSilently(getFile()));//CodeInsightSettings.getInstance().ADD_UNAMBIGIOUS_IMPORTS_ON_THE_FLY = old;
}
 

import com.intellij.openapi.command.undo.UndoManager; //导入依赖的package包/类
public static void cleanupApplicationCaches(Project project) {
  if (project != null && !project.isDisposed()) {
    UndoManagerImpl globalInstance = (UndoManagerImpl)UndoManager.getGlobalInstance();
    if (globalInstance != null) {
      globalInstance.dropHistoryInTests();
    }
    ((UndoManagerImpl)UndoManager.getInstance(project)).dropHistoryInTests();

    ((PsiManagerImpl)PsiManager.getInstance(project)).cleanupForNextTest();
  }

  ProjectManagerImpl projectManager = (ProjectManagerImpl)ProjectManager.getInstance();
  if (projectManager.isDefaultProjectInitialized()) {
    Project defaultProject = projectManager.getDefaultProject();
    ((PsiManagerImpl)PsiManager.getInstance(defaultProject)).cleanupForNextTest();
  }

  LocalFileSystemImpl localFileSystem = (LocalFileSystemImpl)LocalFileSystem.getInstance();
  if (localFileSystem != null) {
    localFileSystem.cleanupForNextTest();
  }

}
 

import com.intellij.openapi.command.undo.UndoManager; //导入依赖的package包/类
@Override
public Document createWorkingDocument(final Project project) {
  //TODO[ik]: do we really need to create copy here?
  final Document workingDocument = myDocument; //DocumentUtil.createCopy(myDocument, project);
  //LOG.assertTrue(workingDocument != myDocument);
  workingDocument.setReadOnly(false);
  final DocumentReference ref = DocumentReferenceManager.getInstance().create(workingDocument);
  myTextBeforeMerge = myDocument.getText();
  ApplicationManager.getApplication().runWriteAction(new Runnable() {
    @Override
    public void run() {
      setDocumentText(workingDocument, myOriginalText, DiffBundle.message("merge.init.merge.content.command.name"), project);
      if (project != null) {
        final UndoManager undoManager = UndoManager.getInstance(project);
        if (undoManager != null) { //idea.sh merge command
          undoManager.nonundoableActionPerformed(ref, false);
        }
      }
    }
  });
  return workingDocument;
}
 

import com.intellij.openapi.command.undo.UndoManager; //导入依赖的package包/类
public void update(AnActionEvent event) {
  Presentation presentation = event.getPresentation();
  DataContext dataContext = event.getDataContext();
  FileEditor editor = PlatformDataKeys.FILE_EDITOR.getData(dataContext);

  // do not allow global undo in dialogs
  if (editor == null) {
    final Boolean isModalContext = PlatformDataKeys.IS_MODAL_CONTEXT.getData(dataContext);
    if (isModalContext != null && isModalContext) {
      presentation.setEnabled(false);
      return;
    }
  }

  UndoManager undoManager = getUndoManager(editor, dataContext);
  if (undoManager == null) {
    presentation.setEnabled(false);
    return;
  }
  presentation.setEnabled(isAvailable(editor, undoManager));

  Pair<String, String> pair = getActionNameAndDescription(editor, undoManager);

  presentation.setText(pair.first);
  presentation.setDescription(pair.second);
}
 

import com.intellij.openapi.command.undo.UndoManager; //导入依赖的package包/类
public void runExecuteAction(@NotNull LanguageConsoleView consoleView) {
  if (!myUseProcessStdIn) {
    beforeExecution(consoleView);
  }

  String text = ((LanguageConsoleImpl)consoleView).prepareExecuteAction(myAddToHistory && !myUseProcessStdIn,
                                                                                   myPreserveMarkup, true);
  ((UndoManagerImpl)UndoManager.getInstance(consoleView.getProject())).invalidateActionsFor(DocumentReferenceManager.getInstance().create(
    consoleView.getCurrentEditor().getDocument()));

  if (myUseProcessStdIn) {
    consoleView.print(text, ConsoleViewContentType.USER_INPUT);
    consoleView.print("\n", ConsoleViewContentType.USER_INPUT);
  }
  else {
    addToCommandHistoryAndExecute(consoleView, text);
  }
}
 

import com.intellij.openapi.command.undo.UndoManager; //导入依赖的package包/类
public static void doRename(final PsiElement element, String newName, UsageInfo[] usages, final Project project,
                            @Nullable final RefactoringElementListener listener) throws IncorrectOperationException{
  final RenamePsiElementProcessor processor = RenamePsiElementProcessor.forElement(element);
  final String fqn = element instanceof PsiFile ? ((PsiFile)element).getVirtualFile().getPath() : CopyReferenceAction.elementToFqn(element);
  if (fqn != null) {
    UndoableAction action = new BasicUndoableAction() {
      @Override
      public void undo() throws UnexpectedUndoException {
        if (listener instanceof UndoRefactoringElementListener) {
          ((UndoRefactoringElementListener)listener).undoElementMovedOrRenamed(element, fqn);
        }
      }

      @Override
      public void redo() throws UnexpectedUndoException {
      }
    };
    UndoManager.getInstance(project).undoableActionPerformed(action);
  }
  processor.renameElement(element, newName, usages, listener);
}
 

import com.intellij.openapi.command.undo.UndoManager; //导入依赖的package包/类
@Override
public void run() {
  FORMATTING_CANCELLED_FLAG.set(true);
  VirtualFile file = myFile.get();
  Document document = myDocument.get();
  if (file == null || document == null || myDocumentModificationStampBefore < 0) {
    return;
  }
  FileEditor editor = FileEditorManager.getInstance(myProject).getSelectedEditor(file);
  if (editor == null) {
    return;
  }

  UndoManager manager = UndoManager.getInstance(myProject);
  while (manager.isUndoAvailable(editor) && document.getModificationStamp() != myDocumentModificationStampBefore) {
    manager.undo(editor);
  }
}
 

import com.intellij.openapi.command.undo.UndoManager; //导入依赖的package包/类
@Override
public void renameElement(PsiElement element, final String newName, UsageInfo[] usages, @Nullable RefactoringElementListener listener)
  throws IncorrectOperationException {
  if (element instanceof PsiField) {
    new RenameJavaVariableProcessor().renameElement(element, newName, usages, listener);
  }
  else {
    if (element instanceof PsiNamedElement) {
      super.renameElement(element, newName, usages, listener);

      if (element instanceof PsiFile) {
        VirtualFile virtualFile = ((PsiFile)element).getVirtualFile();
        if (virtualFile != null && !LocalHistory.getInstance().isUnderControl(virtualFile)) {
          DocumentReference ref = DocumentReferenceManager.getInstance().create(virtualFile);
          UndoManager.getInstance(element.getProject()).nonundoableActionPerformed(ref, false);
        }
      }
    }
    else if (element instanceof XmlAttributeValue) {
      new RenameXmlAttributeProcessor().renameElement(element, newName, usages, listener);
    }
  }
}
 

import com.intellij.openapi.command.undo.UndoManager; //导入依赖的package包/类
public static void execute(final Project project, final UndoableAction action, String name, String groupId) {
  CommandProcessor.getInstance().executeCommand(project, new Runnable() {
    public void run() {

      try {
        action.redo();
      }
      catch (UnexpectedUndoException e) {
        throw new RuntimeException(e);
      }
      UndoManager.getInstance(project).undoableActionPerformed(action);

    }
  }, name, groupId);

}
 

import com.intellij.openapi.command.undo.UndoManager; //导入依赖的package包/类
@CalledInAwt
private static void markUnshelvedFilesNonUndoable(@NotNull final Project project,
                                                  @NotNull List<ShelvedChange> changes) {
  final UndoManagerImpl undoManager = (UndoManagerImpl)UndoManager.getInstance(project);
  if (undoManager != null && !changes.isEmpty()) {
    ContainerUtil.process(changes, new Processor<ShelvedChange>() {
      @Override
      public boolean process(ShelvedChange change) {
        final VirtualFile vfUnderProject = VfsUtil.findFileByIoFile(new File(project.getBasePath(), change.getAfterPath()), false);
        if (vfUnderProject != null) {
          final DocumentReference documentReference = DocumentReferenceManager.getInstance().create(vfUnderProject);
          undoManager.nonundoableActionPerformed(documentReference, false);
          undoManager.invalidateActionsFor(documentReference);
        }
        return true;
      }
    });
  }
}
 

import com.intellij.openapi.command.undo.UndoManager; //导入依赖的package包/类
@Override
protected void doFix(final Project project, ProblemDescriptor descriptor) {
  addRemoveTestsScope(project, true);
  final VirtualFile vFile = descriptor.getPsiElement().getContainingFile().getVirtualFile();
  UndoManager.getInstance(project).undoableActionPerformed(new BasicUndoableAction(vFile) {
    @Override
    public void undo() throws UnexpectedUndoException {
      addRemoveTestsScope(project, false);
    }

    @Override
    public void redo() throws UnexpectedUndoException {
      addRemoveTestsScope(project, true);
    }
  });
}
 

import com.intellij.openapi.command.undo.UndoManager; //导入依赖的package包/类
private boolean doMoveRename(final VirtualFile file, final VirtualFile newParent, final String newName) throws IOException {
  if (!CvsUtil.fileIsUnderCvs(file)) return false;
  if (newParent == null) return false;
  final File newFile = new File(newParent.getPath(), newName);
  myComponent.getDeleteHandler().addDeletedRoot(file);
  if (!file.isDirectory()) {
    myComponent.getAddHandler().addFile(newFile);
    return false;
  }
  newFile.mkdir();
  copyDirectoryStructure(file, newFile);
  myComponent.getAddHandler().addFile(newFile);
  final DocumentReference ref = DocumentReferenceManager.getInstance().create(file);
  UndoManager.getInstance(myProject).nonundoableActionPerformed(ref, false);
  return true;
}
 

import com.intellij.openapi.command.undo.UndoManager; //导入依赖的package包/类
public static void invokeOnTheFlyImportOptimizer(@NotNull final Runnable runnable,
                                                 @NotNull final PsiFile file,
                                                 @NotNull final Editor editor) {
  final long stamp = editor.getDocument().getModificationStamp();
  ApplicationManager.getApplication().invokeLater(new Runnable() {
    @Override
    public void run() {
      if (file.getProject().isDisposed() || editor.isDisposed() || editor.getDocument().getModificationStamp() != stamp) return;
      //no need to optimize imports on the fly during undo/redo
      final UndoManager undoManager = UndoManager.getInstance(editor.getProject());
      if (undoManager.isUndoInProgress() || undoManager.isRedoInProgress()) return;
      PsiDocumentManager.getInstance(file.getProject()).commitAllDocuments();
      String beforeText = file.getText();
      final long oldStamp = editor.getDocument().getModificationStamp();
      DocumentUtil.writeInRunUndoTransparentAction(runnable);
      if (oldStamp != editor.getDocument().getModificationStamp()) {
        String afterText = file.getText();
        if (Comparing.strEqual(beforeText, afterText)) {
          String path = file.getViewProvider().getVirtualFile().getPath();
          LOG.error("Import optimizer  hasn't optimized any imports", new Attachment(path, afterText));
        }
      }
    }
  });
}
 

import com.intellij.openapi.command.undo.UndoManager; //导入依赖的package包/类
@Override
public void handleQualifiedNameChange(final PsiPackage psiPackage, final String newQualifiedName) {
  ApplicationManager.getApplication().assertWriteAccessAllowed();
  final String oldQualifedName = psiPackage.getQualifiedName();
  final boolean anyChanged = changePackagePrefixes(psiPackage, oldQualifedName, newQualifiedName);
  if (anyChanged) {
    UndoManager.getInstance(psiPackage.getProject()).undoableActionPerformed(new GlobalUndoableAction() {
      @Override
      public void undo() {
        changePackagePrefixes(psiPackage, newQualifiedName, oldQualifedName);
      }

      @Override
      public void redo() {
        changePackagePrefixes(psiPackage, oldQualifedName, newQualifiedName);
      }
    });
  }
}
 

import com.intellij.openapi.command.undo.UndoManager; //导入依赖的package包/类
public void testAutoImportWorks() throws Throwable {
  @NonNls final String text = "class S { JFrame x; <caret> }";
  configureByText(StdFileTypes.JAVA, text);
  ((UndoManagerImpl)UndoManager.getInstance(getProject())).flushCurrentCommandMerger();
  ((UndoManagerImpl)UndoManager.getInstance(getProject())).clearUndoRedoQueueInTests(getFile().getVirtualFile());
  assertFalse(((DaemonCodeAnalyzerImpl)DaemonCodeAnalyzer.getInstance(getProject())).canChangeFileSilently(getFile()));


  doHighlighting();
  assertFalse(((DaemonCodeAnalyzerImpl)DaemonCodeAnalyzer.getInstance(getProject())).canChangeFileSilently(getFile()));

  type(" ");
  assertTrue(((DaemonCodeAnalyzerImpl)DaemonCodeAnalyzer.getInstance(getProject())).canChangeFileSilently(getFile()));

  undo();

  assertFalse(((DaemonCodeAnalyzerImpl)DaemonCodeAnalyzer.getInstance(getProject())).canChangeFileSilently(getFile()));//CodeInsightSettings.getInstance().ADD_UNAMBIGIOUS_IMPORTS_ON_THE_FLY = old;
}
 

import com.intellij.openapi.command.undo.UndoManager; //导入依赖的package包/类
public static void cleanupApplicationCaches(Project project) {
  if (project != null && !project.isDisposed()) {
    UndoManagerImpl globalInstance = (UndoManagerImpl)UndoManager.getGlobalInstance();
    if (globalInstance != null) {
      globalInstance.dropHistoryInTests();
    }
    ((UndoManagerImpl)UndoManager.getInstance(project)).dropHistoryInTests();

    ((PsiManagerEx)PsiManager.getInstance(project)).getFileManager().cleanupForNextTest();
  }

  LocalFileSystemImpl localFileSystem = (LocalFileSystemImpl)LocalFileSystem.getInstance();
  if (localFileSystem != null) {
    localFileSystem.cleanupForNextTest();
  }

  LocalHistoryImpl.getInstanceImpl().cleanupForNextTest();

  PatchedWeakReference.clearAll();
}
 

import com.intellij.openapi.command.undo.UndoManager; //导入依赖的package包/类
public Document createWorkingDocument(final Project project) {
  //TODO[ik]: do we really need to create copy here?
  final Document workingDocument = myDocument; //DocumentUtil.createCopy(myDocument, project);
  //LOG.assertTrue(workingDocument != myDocument);
  workingDocument.setReadOnly(false);
  final DocumentReference ref = DocumentReferenceManager.getInstance().create(workingDocument);
  myTextBeforeMerge = myDocument.getText();
  ApplicationManager.getApplication().runWriteAction(new Runnable() {
    public void run() {
      setDocumentText(workingDocument, myOriginalText, DiffBundle.message("merge.init.merge.content.command.name"), project);
      if (project != null) {
        final UndoManager undoManager = UndoManager.getInstance(project);
        if (undoManager != null) { //idea.sh merge command
          undoManager.nonundoableActionPerformed(ref, false);
        }
      }
    }
  });
  return workingDocument;
}
 

import com.intellij.openapi.command.undo.UndoManager; //导入依赖的package包/类
public void runExecuteAction(LanguageConsoleImpl languageConsole) {

    // Process input and add to history
    final Document document = languageConsole.getCurrentEditor().getDocument();
    final String text = document.getText();
    final TextRange range = new TextRange(0, document.getTextLength());

    languageConsole.getCurrentEditor().getSelectionModel().setSelection(range.getStartOffset(), range.getEndOffset());
    if (myAddCurrentToHistory) {
      languageConsole.addCurrentToHistory(range, false, myPreserveMarkup);
    }

    languageConsole.setInputText("");

    final UndoManager manager = languageConsole.getProject() == null ? UndoManager.getGlobalInstance() : UndoManager.getInstance(
      languageConsole.getProject());

    ((UndoManagerImpl)manager).invalidateActionsFor(DocumentReferenceManager.getInstance().create(document));

    myConsoleHistoryModel.addToHistory(text);
    // Send to interpreter / server

    processLine(text);
  }