Java ProgressWindow类代码示例

import com.intellij.openapi.progress.util.ProgressWindow; //导入依赖的package包/类
public void uploadExercise(Project project) {

        new ButtonInputListener().receiveSubmit();

        ProgressWindow window =
                ProgressWindowMaker.make(
                        "Uploading exercise, this may take several minutes",
                        project,
                        true,
                        true,
                        true);
        CoreProgressObserver observer = new CoreProgressObserver(window);
        FileDocumentManager.getInstance().saveAllDocuments();

        callExerciseUploadService(project, observer, window);
    }
 

import com.intellij.openapi.progress.util.ProgressWindow; //导入依赖的package包/类
private void callExerciseUploadService(
        Project project, CoreProgressObserver observer, ProgressWindow window) {

    new ExerciseUploadingService()
            .startUploadExercise(
                    project,
                    TmcCoreHolder.get(),
                    new ObjectFinder(),
                    new CheckForExistingExercises(),
                    new SubmissionResultHandler(),
                    TmcSettingsManager.get(),
                    new CourseAndExerciseManager(),
                    new ThreadingService(),
                    new TestRunningService(),
                    observer,
                    window);
}
 

import com.intellij.openapi.progress.util.ProgressWindow; //导入依赖的package包/类
private void startDownloadExercise(Project project, boolean downloadAll) throws Exception {
    ProgressWindow window =
            ProgressWindowMaker.make(
                    "Downloading exercises, this may take several minutes",
                    project,
                    true,
                    true,
                    true);
    ExerciseDownloadingService
            .startDownloadExercise(
                    TmcCoreHolder.get(),
                    TmcSettingsManager.get(),
                    new CheckForExistingExercises(),
                    new ObjectFinder(),
                    new ThreadingService(),
                    project,
                    downloadAll,
                    window);
}
 

import com.intellij.openapi.progress.util.ProgressWindow; //导入依赖的package包/类
public void runTests(
        final Exercise exercise,
        Project project,
        ThreadingService threadingService,
        ObjectFinder finder) {
    logger.info("Starting to run tests for current project. @TestRunningService");

    ProgressWindow window =
            ProgressWindowMaker.make("Running tests", project, true, true, true);
    CoreProgressObserver observer = new CoreProgressObserver(window);

    if (exercise != null) {
        prepareThreadForRunningTests(
                exercise, project, threadingService, finder, window, observer);
    } else {
        Exception exception = new Exception();
        logger.warn(
                "Running tests failed, exercise {} was not "
                        + "recognized. @TestRunningService",
                exercise,
                exception);
        new ErrorMessageService()
                .showErrorMessage(
                        exception, "Running tests failed, exercise was not recognized", true);
    }
}
 

import com.intellij.openapi.progress.util.ProgressWindow; //导入依赖的package包/类
public static void startDownloadExercise(
        final TmcCore core,
        final SettingsTmc settings,
        final CheckForExistingExercises checker,
        ObjectFinder objectFinder,
        ThreadingService threadingService,
        Project project,
        boolean downloadAll,
        ProgressWindow window) {

    logger.info(
            "Preparing to start checking for available exercises."
                    + "@ExerciseDownloadingService");
    Thread run = checkAvailableExercises(core, settings, checker, objectFinder, downloadAll);
    threadingService.runWithNotification(run, project, window);
}
 

import com.intellij.openapi.progress.util.ProgressWindow; //导入依赖的package包/类
@NotNull
private JButton addFunctionalityToRefreshButton() {
    logger.info("Adding functionality to refresh projects button. "
            + "@ProjectListWindow");
    JButton refreshButton = new JButton(TmcIcons.REFRESH);
    refreshButton.setBorderPainted(true);
    refreshButton.setEnabled(true);

    ProgressWindow window = ProgressWindowMaker.make("Refreshing project list",
            new ObjectFinder().findCurrentProject(), false, true, true);

    refreshButton.addActionListener(actionEvent -> {
        ThreadingService threadingService = new ThreadingService();
        threadingService.runWithNotification(
                new Thread(() -> refreshProjectList()),
                new ObjectFinder().findCurrentProject(),
                window);
    });

    return refreshButton;
}
 

import com.intellij.openapi.progress.util.ProgressWindow; //导入依赖的package包/类
@Test
public void afterUploadingExercisesTheCourseIsUpdated() {
    ObjectFinder finder = mock(ObjectFinder.class);
    CheckForExistingExercises checker = mock(CheckForExistingExercises.class);
    SettingsTmc settings = mock(SettingsTmc.class);
    ThreadingService threadingService = mock(ThreadingService.class);
    Course course = new Course("home");

    Project project = mock(Project.class);
    when(project.getBasePath()).thenReturn("/home/user");

    CourseAndExerciseManager mockCourseAndExerciseManager = mock(CourseAndExerciseManager.class);
    when(mockCourseAndExerciseManager.isCourseInDatabase(course.getName())).thenReturn(true);

    ProgressWindow window = mock(ProgressWindow.class);
    CoreProgressObserver observer = mock(CoreProgressObserver.class);

    new ExerciseUploadingService().startUploadExercise(project, mock(TmcCore.class), finder, checker,
            mock(SubmissionResultHandler.class), settings,
            mockCourseAndExerciseManager, threadingService, mock(TestRunningService.class),
            observer, window);

    verify(threadingService).runWithNotification(any(Runnable.class), any(Project.class), any(ProgressWindow.class));
    verify(mockCourseAndExerciseManager).updateSingleCourse(course.getName(),
            checker, finder, settings);
}
 

import com.intellij.openapi.progress.util.ProgressWindow; //导入依赖的package包/类
private static void waitForFileWatcher(@NotNull ProgressIndicator indicator) {
  LocalFileSystem fs = LocalFileSystem.getInstance();
  if (!(fs instanceof LocalFileSystemImpl)) return;

  final FileWatcher watcher = ((LocalFileSystemImpl)fs).getFileWatcher();
  if (!watcher.isOperational() || !watcher.isSettingRoots()) return;

  LOG.info("FW/roots waiting started");
  indicator.setIndeterminate(true);
  indicator.setText(ProjectBundle.message("project.load.waiting.watcher"));
  if (indicator instanceof ProgressWindow) {
    ((ProgressWindow)indicator).setCancelButtonText(CommonBundle.message("button.skip"));
  }
  while (watcher.isSettingRoots() && !indicator.isCanceled()) {
    TimeoutUtil.sleep(10);
  }
  LOG.info("FW/roots waiting finished");
}
 

import com.intellij.openapi.progress.util.ProgressWindow; //导入依赖的package包/类
private void waitForFileWatcher(@NotNull Project project) {
  LocalFileSystem fs = LocalFileSystem.getInstance();
  if (!(fs instanceof LocalFileSystemImpl)) return;

  final FileWatcher watcher = ((LocalFileSystemImpl)fs).getFileWatcher();
  if (!watcher.isOperational() || !watcher.isSettingRoots()) return;

  LOG.info("FW/roots waiting started");
  Task.Modal task = new Task.Modal(project, ProjectBundle.message("project.load.progress"), true) {
    @Override
    public void run(@NotNull ProgressIndicator indicator) {
      indicator.setIndeterminate(true);
      indicator.setText(ProjectBundle.message("project.load.waiting.watcher"));
      if (indicator instanceof ProgressWindow) {
        ((ProgressWindow)indicator).setCancelButtonText(CommonBundle.message("button.skip"));
      }
      while (watcher.isSettingRoots() && !indicator.isCanceled()) {
        TimeoutUtil.sleep(10);
      }
      LOG.info("FW/roots waiting finished");
    }
  };
  myProgressManager.run(task);
}
 

import com.intellij.openapi.progress.util.ProgressWindow; //导入依赖的package包/类
@RequiredDispatchThread
public void rediff(boolean trySync) {
  if (isDisposed()) return;
  abortRediff();

  fireEvent(EventType.BEFORE_REDIFF);
  onBeforeRediff();

  boolean forceEDT = forceRediffSynchronously();
  int waitMillis = trySync || tryRediffSynchronously() ? ProgressWindow.DEFAULT_PROGRESS_DIALOG_POSTPONE_TIME_MILLIS : 0;

  myTaskExecutor.executeAndTryWait(
          indicator -> {
            final Runnable callback = performRediff(indicator);
            return () -> {
              callback.run();
              onAfterRediff();
              fireEvent(EventType.AFTER_REDIFF);
            };
          },
          this::onSlowRediff, waitMillis, forceEDT
  );
}
 

import com.intellij.openapi.progress.util.ProgressWindow; //导入依赖的package包/类
@Override
public void executeProcessUnderProgress(@Nonnull Runnable process, ProgressIndicator progress) throws ProcessCanceledException {
  if (progress instanceof ProgressWindow) myCurrentUnsafeProgressCount.incrementAndGet();

  CheckCanceledHook hook = progress instanceof PingProgress && ApplicationManager.getApplication().isDispatchThread()
                           ? p -> { ((PingProgress)progress).interact(); return true; }
                           : null;
  if (hook != null) addCheckCanceledHook(hook);

  try {
    super.executeProcessUnderProgress(process, progress);
  }
  finally {
    if (progress instanceof ProgressWindow) myCurrentUnsafeProgressCount.decrementAndGet();
    if (hook != null) removeCheckCanceledHook(hook);
  }
}
 

import com.intellij.openapi.progress.util.ProgressWindow; //导入依赖的package包/类
public static void runProcessWithProgress(Project project, Runnable runnable) {
        ProgressWindow progressIndicator = new ProgressWindow(false, project);
        progressIndicator.setIndeterminate(true);

        runSync(project, runnable);
//        runAsync(project, runnable, progressIndicator);
    }
 

import com.intellij.openapi.progress.util.ProgressWindow; //导入依赖的package包/类
public void runWithNotification(
        final Runnable run, Project project, ProgressWindow progressWindow) {
    logger.info("Processing runWithNotification. @ThreadingService");

    ApplicationManager.getApplication()
            .executeOnPooledThread(
                    () -> ProgressManager.getInstance().runProcess(run, progressWindow));
}
 

import com.intellij.openapi.progress.util.ProgressWindow; //导入依赖的package包/类
public static ProgressWindow make(
        String title,
        Project project,
        boolean cancelable,
        boolean hidable,
        boolean indeterminate) {
    logger.info("Creating progress window. @ProgressWindowMaker");
    ProgressWindow progressWindow = new ProgressWindow(cancelable, hidable, project);
    progressWindow.setIndeterminate(indeterminate);
    progressWindow.setTitle(title);
    progressWindow.setDelayInMillis(500);

    return progressWindow;
}
 

import com.intellij.openapi.progress.util.ProgressWindow; //导入依赖的package包/类
public static void startDownloading(List<Exercise> exercises) {
    logger.info("Preparing to start downloading exercises. @ExerciseDownloadingService");
    ProgressWindow window =
            ProgressWindowMaker.make(
                    "Downloading exercises, this may take a while",
                    new ObjectFinder().findCurrentProject(),
                    true,
                    true,
                    false);
    CoreProgressObserver observer = new CoreProgressObserver(window);
    Thread run = downloadSelectedExercises(TmcCoreHolder.get(), exercises, observer);
    ThreadingService threadingService = new ThreadingService();
    Project project = new ObjectFinder().findCurrentProject();
    threadingService.runWithNotification(run, project, window);
}