@Override
 public void setCancelButtonText(String cancelButtonText) {
   ProgressIndicator progressIndicator = getProgressIndicator();
   if (progressIndicator != null) {
     if (progressIndicator instanceof SmoothProgressAdapter && cancelButtonText != null) {
       ProgressIndicator original =
           ((SmoothProgressAdapter) progressIndicator).getOriginalProgressIndicator();
       if (original instanceof ProgressWindow) {
         ((ProgressWindow) original).setCancelButtonText(cancelButtonText);
       }
     }
   }
 }
  public boolean runProcessWithProgressSynchronously(
      @NotNull final Runnable process,
      @NotNull final String progressTitle,
      final boolean canBeCanceled,
      @Nullable final Project project,
      final JComponent parentComponent,
      final String cancelText) {
    assertIsDispatchThread();

    if (myExceptionalThreadWithReadAccessRunnable != null
        || ApplicationManager.getApplication().isUnitTestMode()
        || ApplicationManager.getApplication().isHeadlessEnvironment()) {
      try {
        ProgressManager.getInstance().runProcess(process, new EmptyProgressIndicator());
      } catch (ProcessCanceledException e) {
        // ok to ignore.
        return false;
      }
      return true;
    }

    final ProgressWindow progress =
        new ProgressWindow(canBeCanceled, false, project, parentComponent, cancelText);
    progress.setTitle(progressTitle);

    try {
      myExceptionalThreadWithReadAccessRunnable = process;
      final boolean[] threadStarted = {false};
      SwingUtilities.invokeLater(
          new Runnable() {
            public void run() {
              if (myExceptionalThreadWithReadAccessRunnable != process) {
                LOG.error(
                    "myExceptionalThreadWithReadAccessRunnable != process, process = "
                        + myExceptionalThreadWithReadAccessRunnable);
              }

              executeOnPooledThread(
                  new Runnable() {
                    public void run() {
                      if (myExceptionalThreadWithReadAccessRunnable != process) {
                        LOG.error(
                            "myExceptionalThreadWithReadAccessRunnable != process, process = "
                                + myExceptionalThreadWithReadAccessRunnable);
                      }

                      final boolean old = setExceptionalThreadWithReadAccessFlag(true);
                      LOG.assertTrue(isReadAccessAllowed());
                      try {
                        ProgressManager.getInstance().runProcess(process, progress);
                      } catch (ProcessCanceledException e) {
                        progress.cancel();
                        // ok to ignore.
                      } catch (RuntimeException e) {
                        progress.cancel();
                        throw e;
                      } finally {
                        setExceptionalThreadWithReadAccessFlag(old);
                        makeChangesVisibleToEDT();
                      }
                    }
                  });
              threadStarted[0] = true;
            }
          });

      progress.startBlocking();

      LOG.assertTrue(threadStarted[0]);
      LOG.assertTrue(!progress.isRunning());
    } finally {
      myExceptionalThreadWithReadAccessRunnable = null;
      makeChangesVisibleToEDT();
    }

    return !progress.isCanceled();
  }
  private void runLayoutCodeProcess(
      final Runnable readAction, final Runnable writeAction, final boolean globalAction) {
    final ProgressWindow progressWindow = new ProgressWindow(true, myProject);
    progressWindow.setTitle(myCommandName);
    progressWindow.setText(myProgressText);

    final ModalityState modalityState = ModalityState.current();

    final Runnable process =
        new Runnable() {
          @Override
          public void run() {
            ApplicationManager.getApplication().runReadAction(readAction);
          }
        };

    Runnable runnable =
        new Runnable() {
          @Override
          public void run() {
            try {
              ProgressManager.getInstance().runProcess(process, progressWindow);
            } catch (ProcessCanceledException e) {
              return;
            } catch (IndexNotReadyException e) {
              return;
            }

            final Runnable writeRunnable =
                new Runnable() {
                  @Override
                  public void run() {
                    CommandProcessor.getInstance()
                        .executeCommand(
                            myProject,
                            new Runnable() {
                              @Override
                              public void run() {
                                if (globalAction)
                                  CommandProcessor.getInstance()
                                      .markCurrentCommandAsGlobal(myProject);
                                try {
                                  writeAction.run();

                                  if (myPostRunnable != null) {
                                    ApplicationManager.getApplication().invokeLater(myPostRunnable);
                                  }
                                } catch (IndexNotReadyException ignored) {
                                }
                              }
                            },
                            myCommandName,
                            null);
                  }
                };

            if (ApplicationManager.getApplication().isUnitTestMode()) {
              writeRunnable.run();
            } else {
              ApplicationManager.getApplication()
                  .invokeLater(writeRunnable, modalityState, myProject.getDisposed());
            }
          }
        };

    if (ApplicationManager.getApplication().isUnitTestMode()) {
      runnable.run();
    } else {
      ApplicationManager.getApplication().executeOnPooledThread(runnable);
    }
  }