com.intellij.openapi.application.ModalityState Java Examples

/**
 * Synchronously shows a yes/no dialog. This method must not be called from a write safe context
 * as it needs to be executed synchronously and AWT actions are not allowed from a write safe
 * context.
 *
 * @param project the project used as a reference to generate and position the dialog
 * @param message the text displayed as the message of the dialog
 * @param title the text displayed as the title of the dialog
 * @return <code>true</code> if {@link Messages#YES} is chosen or <code>false</code> if {@link
 *     Messages#NO} is chosen or the dialog is closed
 * @throws IllegalAWTContextException if the calling thread is currently inside a write safe
 *     context
 * @throws IllegalStateException if no response value was received from the dialog or the response
 *     was not {@link Messages#YES} or {@link Messages#NO}.
 */
public static boolean showYesNoDialog(Project project, final String message, final String title)
    throws IllegalAWTContextException {

  if (application.isWriteAccessAllowed()) {
    throw new IllegalAWTContextException("AWT events are not allowed inside write actions.");
  }

  log.info("Showing yes/no dialog: " + title + " - " + message);

  Integer result =
      EDTExecutor.invokeAndWait(
          (Computable<Integer>)
              () -> Messages.showYesNoDialog(project, message, title, Messages.getQuestionIcon()),
          ModalityState.defaultModalityState());

  switch (result) {
    case Messages.YES:
      return true;
    case Messages.NO:
      return false;
    default:
      throw new IllegalStateException("Encountered unknown dialog answer " + result);
  }
}
 

void execute(@Nonnull BrowseMode browseMode) {
  myBrowseMode = browseMode;

  if (PsiDocumentManager.getInstance(myProject).getPsiFile(myHostEditor.getDocument()) == null) return;

  int selStart = myHostEditor.getSelectionModel().getSelectionStart();
  int selEnd = myHostEditor.getSelectionModel().getSelectionEnd();

  if (myHostOffset >= selStart && myHostOffset < selEnd) {
    disposeHighlighter();
    return;
  }

  myExecutionProgress = ReadAction.nonBlocking(() -> doExecute()).withDocumentsCommitted(myProject).expireWhen(() -> isTaskOutdated(myHostEditor))
          .finishOnUiThread(ModalityState.defaultModalityState(), Runnable::run).submit(AppExecutorUtil.getAppExecutorService());
}
 

@Override
public void hierarchyChanged(@Nonnull HierarchyEvent e) {
  if (isDisposed()) return;

  if ((e.getChangeFlags() & HierarchyEvent.SHOWING_CHANGED) > 0) {
    final Runnable runnable = () -> {
      final Component c = myComponent.get();
      if (isDisposed() || c == null) return;

      if (c.isShowing()) {
        showNotify();
      }
      else {
        hideNotify();
      }
    };
    final Application app = ApplicationManager.getApplication();
    if (app != null && app.isDispatchThread()) {
      app.invokeLater(runnable, ModalityState.current());
    }
    else {
      //noinspection SSBasedInspection
      SwingUtilities.invokeLater(runnable);
    }
  }
}
 

private void updateGutterSize() {
  assertIsDispatchThread();
  if (!updatingSize) {
    updatingSize = true;
    ApplicationManager.getApplication().invokeLater(() -> {
      try {
        if (!isDisposed()) {
          myGutterComponent.updateSize();
        }
      }
      finally {
        updatingSize = false;
      }
    }, ModalityState.any(), __ -> isDisposed());
  }
}
 

private void refreshLatestVersions(@Nonnull final PackageManagementService packageManagementService) {
  final Application application = ApplicationManager.getApplication();
  application.executeOnPooledThread(() -> {
    if (packageManagementService == myPackageManagementService) {
      try {
        List<RepoPackage> packages = packageManagementService.reloadAllPackages();
        final Map<String, RepoPackage> packageMap = buildNameToPackageMap(packages);
        application.invokeLater(() -> {
          for (int i = 0; i != myPackagesTableModel.getRowCount(); ++i) {
            final InstalledPackage pyPackage = (InstalledPackage)myPackagesTableModel.getValueAt(i, 0);
            final RepoPackage repoPackage = packageMap.get(pyPackage.getName());
            myPackagesTableModel.setValueAt(repoPackage == null ? null : repoPackage.getLatestVersion(), i, 2);
          }
          myPackagesTable.setPaintBusy(false);
        }, ModalityState.stateForComponent(myPackagesTable));
      }
      catch (IOException ignored) {
        myPackagesTable.setPaintBusy(false);
      }
    }
  });
}
 

@RequiredUIAccess
@Nonnull
@Override
public ToolbarComponents init() {
  if (myRequest instanceof UnknownFileTypeDiffRequest) {
    String fileName = ((UnknownFileTypeDiffRequest)myRequest).getFileName();
    if (fileName != null && FileTypeManager.getInstance().getFileTypeByFileName(fileName) != UnknownFileType.INSTANCE) {
      // FileType was assigned elsewhere (ex: by other UnknownFileTypeDiffRequest). We should reload request.
      if (myContext instanceof DiffContextEx) {
        ApplicationManager.getApplication().invokeLater(new Runnable() {
          @Override
          public void run() {
            ((DiffContextEx)myContext).reloadDiffRequest();
          }
        }, ModalityState.current());
      }
    }
  }

  return new ToolbarComponents();
}
 

public static void runExport(final Project project, @Nonnull ThrowableRunnable<IOException> runnable) {
  try {
    runnable.run();
  }
  catch (IOException e) {
    Runnable showError = new Runnable() {
      @Override
      public void run() {
        Messages.showMessageDialog(
          project,
          InspectionsBundle.message("inspection.export.error.writing.to", "export file"),
          InspectionsBundle.message("inspection.export.results.error.title"),
          Messages.getErrorIcon()
        );
      }
    };
    ApplicationManager.getApplication().invokeLater(showError, ModalityState.NON_MODAL);
    throw new ProcessCanceledException();
  }
}
 

private List<Object> calcPopupElements(ChooseByNamePopup popup, String text, boolean checkboxState) {
    List<Object> elements = new ArrayList<>();
    CountDownLatch latch = new CountDownLatch(1);
    //noinspection KotlinInternalInJava
    SwingUtilities.invokeLater(() ->
            popup.scheduleCalcElements(text, checkboxState, ModalityState.NON_MODAL, SelectMostRelevant.INSTANCE,
                    set -> {
                        elements.addAll(set);
                        latch.countDown();
                    }));
    try {
        if (!latch.await(10, TimeUnit.SECONDS)) {
            Assert.fail();
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
    return elements;
}
 

public void focusKey() {
  myKeyField.selectAll();
  //todo[peter,kirillk] without these invokeLaters this requestFocus conflicts with com.intellij.openapi.ui.impl.DialogWrapperPeerImpl.MyDialog.MyWindowListener.windowOpened()
  IdeFocusManager.findInstanceByComponent(myKeyField).requestFocus(myKeyField, true);
  final ModalityState modalityState = ModalityState.stateForComponent(myKeyField);
  ApplicationManager.getApplication().invokeLater(new Runnable() {
    @Override
    public void run() {
      ApplicationManager.getApplication().invokeLater(new Runnable() {
        @Override
        public void run() {
          ApplicationManager.getApplication().invokeLater(new Runnable() {
            @Override
            public void run() {
              IdeFocusManager.findInstanceByComponent(myKeyField).requestFocus(myKeyField, true);
            }
          }, modalityState);
        }
      }, modalityState);
    }
  }, modalityState);
}
 

private void queueUpdate(@Nonnull VirtualFile fileToRefresh) {
  synchronized (myFilesToRefresh) {
    if (myFilesToRefresh.add(fileToRefresh)) {
      myUpdateProblemAlarm.cancelAllRequests();
      myUpdateProblemAlarm.addRequest(new Runnable() {
        @Override
        public void run() {
          if (!myProject.isOpen()) {
            return;
          }
          Set<VirtualFile> filesToRefresh;
          synchronized (myFilesToRefresh) {
            filesToRefresh = new THashSet<VirtualFile>(myFilesToRefresh);
          }
          final DefaultMutableTreeNode rootNode = getRootNode();
          if (rootNode != null) {
            updateNodesContaining(filesToRefresh, rootNode);
          }
          synchronized (myFilesToRefresh) {
            myFilesToRefresh.removeAll(filesToRefresh);
          }
        }
      }, 200, ModalityState.NON_MODAL);
    }
  }
}
 

public void updateUserList() {
    Application app = ApplicationManager.getApplication();
    if (app == null) {
        return;
    }
    app.invokeLater(new Runnable() {
        @Override
        public void run() {
            FlooHandler flooHandler = context.getFlooHandler();
            if (flooHandler == null) {
                return;
            }
            chatForm.updateGravatars();
            chatForm.updateFollowing(flooHandler.state.followedUsers);
            updateTitle();
        }
    }, ModalityState.NON_MODAL);
}
 

public static void queueTaskLater(final Task task) {
    final Application app = ApplicationManager.getApplication();
    if (app.isDispatchThread()) {
        task.queue();
    } else {
        app.invokeLater(
            new Runnable() {
                @Override
                public void run() {
                    task.queue();
                    String test3 = "done";
                }
            },
            ModalityState.any()
        );
        String test4 = "done";
    }
}
 

@Override
public void run() {
  if (!myDisposed && myLoadingPanel.isLoading()) {
    TimeoutUtil.sleep(mySleep);
    ApplicationManager.getApplication().invokeLater(() -> {
      final String s = text.get();
      if (s != null && myLoadingPanel.isLoading()) {
        myLoadingPanel.setLoadingText(s);
      }
    }, ModalityState.stateForComponent(myLoadingPanel));
    myUpdater = new Updater(myLoadingPanel, mySleep);
    myUpdater.start();
  } else {
    myUpdater = null;
  }
}
 

@Override
public void runBare() throws Throwable {
  if (!shouldRunTest()) return;

  try {
    runBareImpl();
  }
  finally {
    try {
      ApplicationManager.getApplication().invokeAndWait(new Runnable() {
        @Override
        public void run() {
          cleanupApplicationCaches(getProject());
          resetAllFields();
        }
      }, ModalityState.NON_MODAL);
    }
    catch (Throwable e) {
      // Ignore
    }
  }
}
 

void restartProcess(Communicator communicator) {
  // will not block here since deadlock can be
  ApplicationManager.getApplication().invokeLater(
    new Runnable() {
      public void run() {
        ApplicationManager.getApplication().runWriteAction(
          new Runnable() {
            public void run() {
              FileDocumentManager.getInstance().saveAllDocuments();
            }
          }
        );
      }
    },
    ModalityState.defaultModalityState()
  );

  doDestroyProcess();
  if (communicator.getProject().isDisposed()) return;
  startProcess(communicator);
}
 

private void launch() {
  LOG.debug("launch");
  if (disposed.get() || launched.getAndSet(true)) return;
  RefreshSession session;
  synchronized (files) {
    if (this.session != null || files.isEmpty()) return;
    ModalityState state = producer.produce();
    LOG.debug("modality state ", state);
    session = RefreshQueue.getInstance().createSession(true, recursive, this::finish, state);
    session.addAllFiles(files);
    this.session = session;
  }
  scheduled.set(false);
  launched.set(false);
  LOG.debug("launched at ", System.currentTimeMillis());
  session.launch();
}
 

/**
 * Hack to have up to date files when doing quickfix stuff...
 * @param path
 */
@NeovimHandler("IntellijOnWrite")
public void intellijOnWrite(String path) {
    ApplicationManager.getApplication().invokeAndWait(() -> {
        PsiFile f = EmbeditorUtil.findTargetFile(path);
        if (f != null) {
            VirtualFile vf = f.getVirtualFile();
            if (vf != null)
                vf.refresh(false, true);
        }
    }, ModalityState.any());
}
 

@TestOnly
public static void dispatchPendingFlushes() {
  if (!isDispatchThread()) throw new IllegalStateException("Must call from EDT");

  Semaphore semaphore = new Semaphore();
  semaphore.down();
  invokeLaterWithCallback(semaphore::up, ModalityState.any(), Conditions.FALSE, null);
  while (!semaphore.isUp()) {
    UIUtil.dispatchAllInvocationEvents();
  }
}
 

public void clearUsers() {
    ApplicationManager.getApplication().invokeLater(new Runnable() {
        @Override
        public void run() {
            chatForm.clearClients();
            updateTitle();
        }
    }, ModalityState.NON_MODAL);
}
 

public void addActivity(@Nonnull UiActivity activity, @Nonnull ModalityState effectiveModalityState) {
  if (!myToWatch.isEmpty() && !myToWatch.contains(activity)) return;

  myActivities.put(activity, new ActivityInfo(effectiveModalityState));
  myQueuedToRemove.remove(activity);

  myContainer.onActivityAdded(activity);
}
 

public BackgroundableTaskData(@Nonnull Task.Backgroundable task,
                              @Nullable ModalityState modalityState,
                              @Nullable ProgressIndicator indicator) {
  myTask = task;
  myModalityState = modalityState;
  myIndicator = indicator;
}
 

public static void invokeLaterIfNeeded(@Nonnull Runnable runnable, @Nonnull ModalityState modalityState, @Nonnull Condition expired) {
  if (ApplicationManager.getApplication().isDispatchThread()) {
    runnable.run();
  } else {
    ApplicationManager.getApplication().invokeLater(runnable, modalityState, expired);
  }
}
 

public void showIfNoProjectOpened() {
  myApplication.invokeLater((DumbAwareRunnable)() -> {
    WindowManagerEx windowManager = (WindowManagerEx)WindowManager.getInstance();
    windowManager.disposeRootFrame();
    IdeFrame[] frames = windowManager.getAllProjectFrames();
    if (frames.length == 0) {
      showFrame();
    }
  }, ModalityState.NON_MODAL);
}
 

@Nonnull
private static CallbackData createInteractive(@Nonnull Project project,
                                              @Nonnull InvokeAfterUpdateMode mode,
                                              @Nonnull Runnable afterUpdate,
                                              String title,
                                              @Nullable ModalityState state) {
  Task task = mode.isSynchronous()
              ? new Waiter(project, afterUpdate, title, mode.isCancellable())
              : new FictiveBackgroundable(project, afterUpdate, title, mode.isCancellable(), state);
  Runnable callback = () -> {
    logUpdateFinished(project, mode);
    setDone(task);
  };
  return new CallbackData(callback, () -> ProgressManager.getInstance().run(task));
}
 

@Override
public ModalityState getModalityState() {
  TimerListener delegate = myRef.get();
  if (delegate != null) {
    return delegate.getModalityState();
  }
  else {
    ActionManagerEx.getInstanceEx().removeTimerListener(this);
    return null;
  }
}
 

boolean isOwnReady() {
  Map<UiActivity, ActivityInfo> infoToCheck = new HashMap<>();

  for (Set<UiActivity> eachActivitySet : myContainer.myActivities2Object.keySet()) {
    final BusyImpl eachBusyObject = myContainer.myActivities2Object.get(eachActivitySet);
    if (eachBusyObject == this) continue;

    for (UiActivity eachOtherActivity : eachActivitySet) {
      for (UiActivity eachToWatch : myToWatch) {
        if (eachToWatch.isSameOrGeneralFor(eachOtherActivity) && eachBusyObject.myActivities.containsKey(eachOtherActivity)) {
          infoToCheck.put(eachOtherActivity, eachBusyObject.myActivities.get(eachOtherActivity));
        }
      }
    }
  }

  infoToCheck.putAll(myActivities);

  if (infoToCheck.isEmpty()) return true;

  final ModalityState current = getCurrentState();
  for (Map.Entry<UiActivity, ActivityInfo> entry : infoToCheck.entrySet()) {
    final ActivityInfo info = entry.getValue();
    if (!current.dominates(info.getEffectiveState())) {
      return false;
    }
  }

  return true;
}
 

@NotNull
private Runnable setForcePressed() {
  myForcePressed = true;
  repaint();

  return () -> {
    // give the button a chance to handle action listener
    ApplicationManager.getApplication().invokeLater(() -> {
      myForcePressed = false;
      repaint();
    }, ModalityState.any());
    repaint();
    fireStateChanged();
  };
}
 

@Override
public void selectFile(@Nonnull final PsiFile file) {
  // Select element in the tree
  ApplicationManager.getApplication().invokeLater(new Runnable() {
    @Override
    public void run() {
      if (myBuilder != null) {
        myBuilder.select(file, file.getVirtualFile(), true);
      }
    }
  }, ModalityState.stateForComponent(getWindow()));
}
 

public static void runOrInvokeAndWaitAboveProgress(final Runnable command, @Nullable final ModalityState modalityState) {
  final Application application = ApplicationManager.getApplication();
  if (application.isDispatchThread()) {
    command.run();
  } else {
    final ProgressIndicator pi = ProgressManager.getInstance().getProgressIndicator();
    if (pi != null) {
      execute(pi);
      application.invokeAndWait(command, pi.getModalityState());
    } else {
      final ModalityState notNullModalityState = modalityState == null ? ModalityState.NON_MODAL : modalityState;
      application.invokeAndWait(command, notNullModalityState);
    }
  }
}
 

/**
 * Clears text on console
 */
public void clear() {
    if (consoleView.isShowing()) {
        consoleView.clear();
    } else {
        ApplicationManager.getApplication().invokeAndWait(new Runnable() {
            @Override
            public void run() {
                consoleView.flushDeferredText();
            }
        }, ModalityState.NON_MODAL);
    }
}