Java Code Examples for consulo.disposer.Disposer#isDisposed()

public static void disposeWithEditor(@Nonnull Editor editor, @Nonnull Disposable disposable) {
  ApplicationManager.getApplication().assertIsDispatchThread();
  if (Disposer.isDisposed(disposable)) return;
  if (editor.isDisposed()) {
    Disposer.dispose(disposable);
    return;
  }
  // for injected editors disposal will happen only when host editor is disposed,
  // but this seems to be the best we can do (there are no notifications on disposal of injected editor)
  Editor hostEditor = editor instanceof EditorWindow ? ((EditorWindow)editor).getDelegate() : editor;
  EditorFactory.getInstance().addEditorFactoryListener(new EditorFactoryAdapter() {
    @Override
    public void editorReleased(@Nonnull EditorFactoryEvent event) {
      if (event.getEditor() == hostEditor) {
        Disposer.dispose(disposable);
      }
    }
  }, disposable);
}
 

@Override
public void showFindDialog(@Nonnull FindModel model, @Nonnull Runnable okHandler) {
  if (myHelper == null || Disposer.isDisposed(myHelper)) {
    myHelper = new FindUIHelper(myProject, model, okHandler);
    Disposer.register(myHelper, new Disposable() {
      @Override
      public void dispose() {
        myHelper = null;
      }
    });
  }
  else {
    myHelper.setModel(model);
    myHelper.setOkHandler(okHandler);
  }
  myHelper.showUI();
}
 

private void runSyncTransaction(@Nonnull Transaction transaction) {
  ApplicationManager.getApplication().assertIsDispatchThread();
  if (Disposer.isDisposed(transaction.parentDisposable)) return;

  boolean wasWritingAllowed = myWritingAllowed;
  myWritingAllowed = true;
  myCurrentTransaction = new TransactionIdImpl(myCurrentTransaction);

  try {
    transaction.runnable.run();
  }
  finally {
    Queue<Transaction> queue = getQueue(myCurrentTransaction.myParent);
    queue.addAll(myCurrentTransaction.myQueue);
    if (!queue.isEmpty()) {
      pollQueueLater();
    }

    myWritingAllowed = wasWritingAllowed;
    myCurrentTransaction.myFinished = true;
    myCurrentTransaction = myCurrentTransaction.myParent;
  }
}
 

@Nullable
public Printer getPrinterByType(@Nonnull String nodeType, @Nonnull String nodeName, @Nullable String nodeArguments) {
  Filter filter = myFilterProvider.getFilter(nodeType, nodeName, nodeArguments);
  if (filter != null && !Disposer.isDisposed(myTestOutputConsoleView)) {
    return new HyperlinkPrinter(myTestOutputConsoleView, HyperlinkPrinter.ERROR_CONTENT_TYPE, filter);
  }
  return null;
}
 

@Override
public void removeNotify() {
  super.removeNotify();
  if (myDisposable != null && !Disposer.isDisposed(myDisposable)) {
    Disposer.dispose(myDisposable);
  }
}
 

@Override
public void dispose() {
  for (FileEditor editor : myEditors) {
    if (!Disposer.isDisposed(editor)) {
      Disposer.dispose(editor);
    }
  }
  myFocusWatcher.deinstall(myFocusWatcher.getTopComponent());
}
 

private static boolean registerIfParentNotDisposed(@Nonnull Disposable parent, @Nonnull Disposable disposable) {
  ThrowableComputable<Boolean, RuntimeException> action = () -> {
    if (Disposer.isDisposed(parent)) return false;
    try {
      Disposer.register(parent, disposable);
      return true;
    }
    catch (IncorrectOperationException ioe) {
      LOG.error(ioe);
      return false;
    }
  };
  return AccessRule.read(action);
}
 

@Override
public void showInBestPositionFor(@Nonnull Editor editor) {
  if (ApplicationManager.getApplication().isUnitTestMode()) {
    handleSelect(true);
    if (!Disposer.isDisposed(this)) {
      Disposer.dispose(this);
    }
  }
  else {
    super.showInBestPositionFor(editor);
  }
}
 

public static boolean register(@Nonnull ScreenAreaConsumer consumer) {
  if (!Registry.is("ide.use.screen.area.tracker", false)) {
    return true;
  }
  if (!Disposer.isDisposed(consumer) && ourAreaConsumers.add(consumer)) {
    Disposer.register(consumer, new Disposable() {
      @Override
      public void dispose() {
        ourAreaConsumers.remove(consumer);
      }
    });
    return true;
  }
  return false;
}
 

@Override
public void removeNotify() {
  super.removeNotify();
  if (!ScreenUtil.isStandardAddRemoveNotify(this)) return;

  if (Disposer.isDisposed(RunnerContentUi.this)) return;

  saveUiState();
}
 

@Override
public void dispose() {
  if (myUI != null && !Disposer.isDisposed(myUI.getDisposable())) {
    Disposer.dispose(myUI.getDisposable());
  }
  myUI = null;
}
 

@Override
public void removeNotify() {
  super.removeNotify();
  if (myDisposable != null && !Disposer.isDisposed(myDisposable)) {
    Disposer.dispose(myDisposable);
  }
}
 

public static boolean isDisposed(Disposable disposable) {
  return Disposer.isDisposed(disposable);
}
 

@Override
public void consume(Object dummy) {
  if (!Disposer.isDisposed(myRepository)) {
    myRepository.update();
  }
}
 

public void processRemoveFromUi() {
  if (Disposer.isDisposed(this)) return;

  updateSelection(false);
}