com.intellij.openapi.fileEditor.FileEditorStateLevel Java Examples

public void testBasics() {
    assertEquals(CsvTableEditor.EDITOR_NAME, fileEditor.getName());
    assertEquals(fileEditor, fileEditor.getCurrentLocation());
    assertInstanceOf(fileEditor.getState(FileEditorStateLevel.FULL), CsvTableEditorState.class);
    assertInstanceOf(fileEditor.getState(FileEditorStateLevel.NAVIGATION), CsvTableEditorState.class);
    assertInstanceOf(fileEditor.getState(FileEditorStateLevel.UNDO), CsvTableEditorState.class);

    CsvTableEditorState myState = new CsvTableEditorState();
    fileEditor.setState(myState);
    assertEquals(myState, fileEditor.getState(FileEditorStateLevel.FULL));

    assertEquals(false, fileEditor.isModified());
    assertEquals(true, fileEditor.isValid());
    assertEquals(null, fileEditor.getBackgroundHighlighter());

    StructureViewBuilder structureViewBuilder = StructureViewBuilder.PROVIDER.getStructureViewBuilder(myFixture.getFile().getFileType(), myFixture.getFile().getVirtualFile(), this.getProject());
    assertInstanceOf(fileEditor.getStructureViewBuilder(), structureViewBuilder.getClass());

    assertEquals(myFixture.getFile().getVirtualFile(), fileEditor.getFile());
    assertEquals(this.getProject(), fileEditor.getProject());
    assertNotNull(fileEditor.getDataHandler());
    assertNotNull(fileEditor.getComponent());
    assertEquals(fileEditor.getTable(), fileEditor.getPreferredFocusedComponent());
}
 

@Nonnull
@Override
public TextEditorState getStateImpl(final Project project, @Nonnull final Editor editor, @Nonnull final FileEditorStateLevel level) {
  final TextEditorState state = super.getStateImpl(project, editor, level);
  // Save folding only on FULL level. It's very expensive to commit document on every
  // type (caused by undo).
  if (FileEditorStateLevel.FULL == level) {
    // Folding
    if (project != null && !project.isDisposed() && !editor.isDisposed() && project.isInitialized()) {
      state.setFoldingState(CodeFoldingManager.getInstance(project).saveFoldingState(editor));
    }
    else {
      state.setFoldingState(null);
    }
  }

  return state;
}
 

private boolean restore(EditorAndState pair, boolean onlyIfDiffers) {
  if (myEditor == null ||
      !myEditor.isValid() || // editor can be invalid if underlying file is deleted during undo (e.g. after undoing scratch file creation)
      pair == null || pair.getEditor() == null) {
    return false;
  }

  // we cannot simply compare editors here because of the following scenario:
  // 1. make changes in editor for file A
  // 2. move caret
  // 3. close editor
  // 4. re-open editor for A via Ctrl-E
  // 5. undo -> position is not affected, because instance created in step 4 is not the same!!!
  if (!myEditor.getClass().equals(pair.getEditor().getClass())) {
    return false;
  }

  // If current editor state isn't equals to remembered state then
  // we have to try to restore previous state. But sometime it's
  // not possible to restore it. For example, it's not possible to
  // restore scroll proportion if editor doesn not have scrolling any more.
  FileEditorState currentState = myEditor.getState(FileEditorStateLevel.UNDO);
  if (onlyIfDiffers && currentState.equals(pair.getState())) {
    return false;
  }

  myEditor.setState(pair.getState());
  return true;
}
 

@Nonnull
TextEditorState getEditorState(@Nonnull FileEditorStateLevel level) {
  ApplicationManager.getApplication().assertIsDispatchThread();


  TextEditorState state = myProvider.getStateImpl(myProject, myEditor, level);
  if (!isDone() && myDelayedState != null) {
    state.setDelayedFoldState(myDelayedState::getFoldingState);
  }
  return state;
}
 

@Override
public boolean canBeMergedWith(FileEditorState otherState, FileEditorStateLevel level) {
  if (!(otherState instanceof TextEditorState)) return false;
  TextEditorState other = (TextEditorState)otherState;
  return level == FileEditorStateLevel.NAVIGATION
         && CARETS != null && CARETS.length == 1
         && other.CARETS != null && other.CARETS.length == 1
         && Math.abs(CARETS[0].LINE - other.CARETS[0].LINE) < MIN_CHANGE_DISTANCE;
}
 

@Override
@Nonnull
public HistoryEntry currentStateAsHistoryEntry() {
  final FileEditor[] editors = getEditors();
  final FileEditorState[] states = new FileEditorState[editors.length];
  for (int j = 0; j < states.length; j++) {
    states[j] = editors[j].getState(FileEditorStateLevel.FULL);
    LOG.assertTrue(states[j] != null);
  }
  final int selectedProviderIndex = ArrayUtil.find(editors, getSelectedEditor());
  LOG.assertTrue(selectedProviderIndex != -1);
  final FileEditorProvider[] providers = getProviders();
  return HistoryEntry.createLight(getFile(), providers, states, providers[selectedProviderIndex]);
}
 

@Nonnull
@Override
public FileEditorState getState(@Nonnull FileEditorStateLevel level) {
  return FileEditorState.INSTANCE;
}
 

@Override
public boolean canBeMergedWith(FileEditorState fileEditorState, FileEditorStateLevel fileEditorStateLevel) {
    return false;
}
 

@Nonnull
@Override
public FileEditorState getState(@Nonnull FileEditorStateLevel level) {
  return null;
}
 

public boolean execute(boolean drop, boolean isInsideStartFinishGroup) {
  if (!myUndoableGroup.isUndoable()) {
    reportCannotUndo(CommonBundle.message("cannot.undo.error.contains.nonundoable.changes.message"),
                     myUndoableGroup.getAffectedDocuments());
    return false;
  }

  Set<DocumentReference> clashing = getStackHolder().collectClashingActions(myUndoableGroup);
  if (!clashing.isEmpty()) {
    reportCannotUndo(CommonBundle.message("cannot.undo.error.other.affected.files.changed.message"), clashing);
    return false;
  }


  if (!isInsideStartFinishGroup && myUndoableGroup.shouldAskConfirmation(isRedo())) {
    if (!askUser()) return false;
  }
  else {
    if (restore(getBeforeState(), true)) {
      setBeforeState(new EditorAndState(myEditor, myEditor.getState(FileEditorStateLevel.UNDO)));
      return true;
    }
  }

  Collection<VirtualFile> readOnlyFiles = collectReadOnlyAffectedFiles();
  if (!readOnlyFiles.isEmpty()) {
    final Project project = myManager.getProject();
    final VirtualFile[] files = VfsUtil.toVirtualFileArray(readOnlyFiles);

    if (project == null) {
      return false;
    }

    final ReadonlyStatusHandler.OperationStatus operationStatus = ReadonlyStatusHandler.getInstance(project).ensureFilesWritable(files);
    if (operationStatus.hasReadonlyFiles()) {
      return false;
    }
  }

  Collection<Document> readOnlyDocuments = collectReadOnlyDocuments();
  if (!readOnlyDocuments.isEmpty()) {
    for (Document document : readOnlyDocuments) {
      document.fireReadOnlyModificationAttempt();
    }
    return false;
  }

  getStackHolder().removeFromStacks(myUndoableGroup);
  if (!drop) {
    getReverseStackHolder().addToStacks(myUndoableGroup);
  }

  performAction();

  restore(getAfterState(), false);

  return true;
}
 

@Nullable
private static TransferableFileEditorState getEditorState(@Nonnull FileEditor editor) {
  FileEditorState state = editor.getState(FileEditorStateLevel.FULL);
  return state instanceof TransferableFileEditorState ? (TransferableFileEditorState)state : null;
}
 

@NotNull
public FileEditorState getState(@NotNull final FileEditorStateLevel ignored) {
	return MY_EDITOR_STATE;
}
 

@Override
public boolean canBeMergedWith(FileEditorState otherState, FileEditorStateLevel level) {
	return false;
}
 

@Nonnull
@Override
public FileEditorState getState(@Nonnull FileEditorStateLevel fileEditorStateLevel)
{
	return FileEditorState.INSTANCE;
}
 

@NotNull
@Override
public FileEditorState getState(@NotNull FileEditorStateLevel level) {
    return FileEditorState.INSTANCE;
}
 

@Override
public boolean canBeMergedWith(FileEditorState fileEditorState, FileEditorStateLevel fileEditorStateLevel) {
  return false;
}
 

@Nonnull
@Override
public FileEditorState getState(@Nonnull FileEditorStateLevel fileEditorStateLevel) {
  return MindMapFileEditorState.DUMMY;
}
 

@Override
public FileEditorState getState(@NotNull FileEditorStateLevel level) {
    return textEditor.getState(level);
}