Java 类com.intellij.openapi.application.ModalityState 实例源码

public static void smartInvokeAndWait(final Project p, final ModalityState state, final Runnable r) {
    if (isNoBackgroundMode() || ApplicationManager.getApplication().isDispatchThread()) {
        r.run();
    } else {
        final Semaphore semaphore = new Semaphore();
        semaphore.down();
        DumbService.getInstance(p).smartInvokeLater(() -> {
            try {
                r.run();
            } finally {
                semaphore.up();
            }
        }, state);
        semaphore.waitFor();
    }
}

private void asyncCheckErrors(@NotNull final Collection<VirtualFile> files,
                              @NotNull final Consumer<Boolean> errorsFoundConsumer) {
  ApplicationManager.getApplication().executeOnPooledThread(new Runnable() {
    @Override
    public void run() {
      final boolean errorsFound = ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
        @Override
        public Boolean compute() {
          for (VirtualFile file : files) {
            if (PsiErrorElementUtil.hasErrors(myProject, file)) {
              return true;
            }
          }
          return false;
        }
      });
      ApplicationManager.getApplication().invokeLater(new Runnable() {
        @Override
        public void run() {
          errorsFoundConsumer.consume(errorsFound);
        }
      }, ModalityState.any());
    }
  });
}

public static PsiDirectory findCurrentDirectory(Project project, VirtualFile file) {
    final PsiDirectory[] result = new PsiDirectory[1];
    ApplicationManager.getApplication().invokeAndWait(() ->
                    result[0] = ApplicationManager.getApplication().runReadAction((Computable<PsiDirectory>) () -> {
                        if (file == null || project == null) {
                            return null;
                        }

                        if (file.isDirectory()) {
                            return PsiManager.getInstance(project).findDirectory(file);
                        } else {
                            return PsiManager.getInstance(project).findDirectory(file.getParent());
                        }
                    })
            , ModalityState.defaultModalityState());
    return result[0];
}

public boolean verifyServerHostKey(final String hostname,
                                   final int port,
                                   final String serverHostKeyAlgorithm,
                                   final String fingerprint,
                                   final boolean isNew) {
  final String message;
  if (isNew) {
    message = GitBundle.message("ssh.new.host.key", hostname, port, fingerprint, serverHostKeyAlgorithm);
  }
  else {
    message = GitBundle.message("ssh.changed.host.key", hostname, port, fingerprint, serverHostKeyAlgorithm);
  }
  final AtomicBoolean rc = new AtomicBoolean();
  ApplicationManager.getApplication().invokeAndWait(new Runnable() {
    public void run() {
      rc.set(Messages.YES == Messages.showYesNoDialog(myProject, message, GitBundle.getString("ssh.confirm.key.titile"), null));
    }
  }, ModalityState.any());
  return rc.get();
}

public void setupSdkPaths(final Sdk sdk, @Nullable final Project project, @Nullable final Component ownerComponent) {
  scheduledToRefresh.add(sdk.getHomePath());
  ApplicationManager.getApplication().invokeLater(new Runnable() {
    @Override
    public void run() {
      try {
        final boolean success = doSetupSdkPaths(project, ownerComponent, PySdkUpdater.fromSdkPath(sdk.getHomePath()));

        if (!success) {
          Messages.showErrorDialog(
            project,
            PyBundle.message("MSG.cant.setup.sdk.$0", FileUtil.toSystemDependentName(sdk.getSdkModificator().getHomePath())),
            PyBundle.message("MSG.title.bad.sdk")
          );
        }
      }
      catch (PySdkUpdater.PySdkNotFoundException e) {
        // sdk was removed from sdk table so no need to setup paths
      }
    }
  }, ModalityState.NON_MODAL);
}

private void addAlarmRequest(){
  Runnable request = new Runnable(){
    @Override
    public void run(){
      if (!myDisposed && !myProject.isDisposed()) {
        DumbService.getInstance(myProject).withAlternativeResolveEnabled(new Runnable() {
          @Override
          public void run() {
            updateComponent();
          }
        });
      }
    }
  };
  myAlarm.addRequest(request, DELAY, ModalityState.stateForComponent(myEditor.getComponent()));
}

public FindDialog(@NotNull Project project, @NotNull FindModel model, @NotNull Consumer<FindModel> myOkHandler){
  super(project, true);
  myProject = project;
  myModel = model;

  this.myOkHandler = myOkHandler;

  updateTitle();
  setOKButtonText(FindBundle.message("find.button"));
  init();
  initByModel();
  updateReplaceVisibility();

  if (haveResultsPreview()) {
    ApplicationManager.getApplication().invokeLater(new Runnable() {
      @Override
      public void run() {
        scheduleResultsUpdate();
      }
    }, ModalityState.any());
  }
}

public void addUpdateRequest(final boolean shouldRefreshSelection) {
  final Runnable request = new Runnable() {
    @Override
    public void run() {
      if (!myProject.isDisposed()) {
        // Rely on project view to commit PSI and wait until it's updated.
        if (myTreeStructure.hasSomethingToCommit() ) {
          myUpdateAlarm.cancelAllRequests();
          myUpdateAlarm.addRequest(this, 300, ModalityState.stateForComponent(myList));
          return;
        }
        updateList(shouldRefreshSelection);
      }
    }
  };

  if (!ApplicationManager.getApplication().isUnitTestMode()) {
    myUpdateAlarm.cancelAllRequests();
    myUpdateAlarm.addRequest(request, 300, ModalityState.stateForComponent(myList));
  }
  else {
    request.run();
  }
}

/**
 * Switches console to "command-mode" (see class doc for details)
 */
private void switchToCommandMode() {
  // "upper" and "bottom" parts of console both need padding in command mode
  myProcessHandler = null;
  setPrompt(getTitle() + " > ");
  ApplicationManager.getApplication().invokeAndWait(new Runnable() {
    @Override
    public void run() {
      notifyStateChangeListeners();
      configureLeftBorder(true, getConsoleEditor(), getHistoryViewer());
      setLanguage(CommandLineLanguage.INSTANCE);
      final CommandLineFile file = PyUtil.as(getFile(), CommandLineFile.class);
      resetConsumer(null);
      if (file == null || myCommandsAndDefaultExecutor == null) {
        return;
      }
      file.setCommands(myCommandsAndDefaultExecutor.first);
      final CommandConsole console = CommandConsole.this;
      resetConsumer(new CommandModeConsumer(myCommandsAndDefaultExecutor.first, myModule, console, myCommandsAndDefaultExecutor.second));
    }
  }, ModalityState.NON_MODAL);
}

private void processClose() {
  if (Registry.getInstance().isRestartNeeded()) {
    final ApplicationEx app = (ApplicationEx) ApplicationManager.getApplication();
    final ApplicationInfo info = ApplicationInfo.getInstance();

    final int r = Messages.showOkCancelDialog(myContent, "You need to restart " + info.getVersionName() + " for the changes to take effect", "Restart Required",
                                              app.isRestartCapable() ? "Restart Now" : "Shutdown Now",
                                              app.isRestartCapable() ? "Restart Later": "Shutdown Later"
        , Messages.getQuestionIcon());


    if (r == Messages.OK) {
      ApplicationManager.getApplication().invokeLater(new Runnable() {
        @Override
        public void run() {
          app.restart(true);
        }
      }, ModalityState.NON_MODAL);
    }
  }
}

private void setMouseSelectionState(@MouseSelectionState int mouseSelectionState) {
  if (getMouseSelectionState() == mouseSelectionState) return;

  myMouseSelectionState = mouseSelectionState;
  myMouseSelectionChangeTimestamp = System.currentTimeMillis();

  myMouseSelectionStateAlarm.cancelAllRequests();
  if (myMouseSelectionState != MOUSE_SELECTION_STATE_NONE) {
    if (myMouseSelectionStateResetRunnable == null) {
      myMouseSelectionStateResetRunnable = new Runnable() {
        @Override
        public void run() {
          resetMouseSelectionState(null);
        }
      };
    }
    myMouseSelectionStateAlarm.addRequest(myMouseSelectionStateResetRunnable, Registry.intValue("editor.mouseSelectionStateResetTimeout"),
                                          ModalityState.stateForComponent(myEditorComponent));
  }
}

@Override
public void projectOpened() {
  MessageBusConnection connection = myProject.getMessageBus().connect(myProject);
  connection.subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootAdapter() {
    @Override
    public void rootsChanged(ModuleRootEvent event) {
      ApplicationManager.getApplication().invokeLater(new Runnable() {
        @Override
        public void run() {
          if (myProject.isDisposed()) return;
          VcsDirtyScopeManager.getInstance(myProject).markEverythingDirty();
        }
      }, ModalityState.NON_MODAL);
    }
  });
  final WolfTheProblemSolver.ProblemListener myProblemListener = new MyProblemListener();
  WolfTheProblemSolver.getInstance(myProject).addProblemListener(myProblemListener,myProject);
}

private void selectLater(final ActionCallback callback, final K key) {
  ApplicationManager.getApplication().executeOnPooledThread(new Runnable() {
    @Override
    public void run() {
      if (!myDisposed) {
        final UI ui = prepare(key);
        ApplicationManager.getApplication().invokeLater(new Runnable() {
          @Override
          public void run() {
            if (!myDisposed) {
              select(callback, key, ui);
            }
            else callback.setRejected();
          }
        }, ModalityState.any());
      }
      else callback.setRejected();
    }
  });
}

@NotNull
private Module loadModuleInternal(@NotNull String filePath) throws ModuleWithNameAlreadyExists, IOException {
  filePath = resolveShortWindowsName(filePath);
  final VirtualFile moduleFile = StandardFileSystems.local().findFileByPath(filePath);
  if (moduleFile == null || !moduleFile.exists()) {
    throw new FileNotFoundException(ProjectBundle.message("module.file.does.not.exist.error", filePath));
  }

  String path = moduleFile.getPath();
  ModuleEx module = getModuleByFilePath(path);
  if (module == null) {
    ApplicationManager.getApplication().invokeAndWait(new Runnable() {
      @Override
      public void run() {
        moduleFile.refresh(false, false);
      }
    }, ModalityState.any());
    module = createAndLoadModule(path);
    initModule(module, path, null);
  }
  return module;
}

private boolean confirmUndeploy() {
  final Ref<Boolean> confirmed = new Ref<Boolean>(false);
  ApplicationManager.getApplication().invokeAndWait(new Runnable() {

    @Override
    public void run() {
      String title = CloudBundle.getText("cloud.undeploy.confirm.title");
      while (true) {
        String password = Messages.showPasswordDialog(CloudBundle.getText("cloud.undeploy.confirm.message", getApplicationName()), title);
        if (password == null) {
          return;
        }
        if (password.equals(getServerRuntime().getConfiguration().getPassword())) {
          confirmed.set(true);
          return;
        }
        Messages.showErrorDialog(CloudBundle.getText("cloud.undeploy.confirm.password.incorrect"), title);
      }
    }
  }, ModalityState.defaultModalityState());
  return confirmed.get();
}

private static void pollDeployments(final ServerConnection connection) {
  connection.computeDeployments(new Runnable() {

    @Override
    public void run() {
      new Alarm().addRequest(new Runnable() {

        @Override
        public void run() {
          if (connection == ServerConnectionManager.getInstance().getConnection(connection.getServer())) {
            pollDeployments(connection);
          }
        }
      }, POLL_DEPLOYMENTS_DELAY, ModalityState.any());
    }
  });
}

private void generate(final Map<AndroidFacet, Collection<AndroidAutogeneratorMode>> facetsToProcess) {
  ApplicationManager.getApplication().invokeAndWait(new Runnable() {
    @Override
    public void run() {
      AndroidCompileUtil.createGenModulesAndSourceRoots(myProject, facetsToProcess.keySet());
    }
  }, ModalityState.defaultModalityState());

  for (Map.Entry<AndroidFacet, Collection<AndroidAutogeneratorMode>> entry : facetsToProcess.entrySet()) {
    final AndroidFacet facet = entry.getKey();
    final Collection<AndroidAutogeneratorMode> modes = entry.getValue();

    for (AndroidAutogeneratorMode mode : modes) {
      AndroidCompileUtil.doGenerate(facet, mode);
    }
  }
}

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

  return new Runnable() {
    @Override
    public void run() {
      // give the button a chance to handle action listener
      ApplicationManager.getApplication().invokeLater(new Runnable() {
        @Override
        public void run() {
          myForcePressed = false;
          myPopup = null;
        }
      }, ModalityState.any());
      repaint();
      fireStateChanged();
    }
  };
}

public static void runOrInvokeLaterAboveProgress(final Runnable command, @Nullable final ModalityState modalityState, @NotNull final Project project) {
  final Application application = ApplicationManager.getApplication();
  if (application.isDispatchThread()) {
    command.run();
  } else {
    final ProgressIndicator pi = ProgressManager.getInstance().getProgressIndicator();
    if (pi != null) {
      execute(pi);
      application.invokeLater(command, pi.getModalityState(), new Condition() {
        @Override
        public boolean value(Object o) {
          return (! project.isOpen()) || project.isDisposed();
        }
      });
    } else {
      final ModalityState notNullModalityState = modalityState == null ? ModalityState.NON_MODAL : modalityState;
      application.invokeLater(command, notNullModalityState, project.getDisposed());
    }
  }
}

@Override
public void activate(@Nullable final Runnable runnable, boolean autoFocusContents, boolean forced) {
  ApplicationManager.getApplication().assertIsDispatchThread();

  final UiActivity activity = new UiActivity.Focus("toolWindow:" + myId);
  UiActivityMonitor.getInstance().addActivity(myToolWindowManager.getProject(), activity, ModalityState.NON_MODAL);

  myToolWindowManager.activateToolWindow(myId, forced, autoFocusContents);

  getActivation().doWhenDone(new Runnable() {
    @Override
    public void run() {
      myToolWindowManager.invokeLater(new Runnable() {
        @Override
        public void run() {
          if (runnable != null) {
            runnable.run();
          }
          UiActivityMonitor.getInstance().removeActivity(myToolWindowManager.getProject(), activity);
        }
      });
    }
  });
}

public static void writeFile(final String folder, @NonNls final String fileName, CharSequence buf, final Project project) {
  try {
    HTMLExporter.writeFileImpl(folder, fileName, buf);
  }
  catch (IOException e) {
    Runnable showError = new Runnable() {
      @Override
      public void run() {
        final String fullPath = folder + File.separator + fileName;
        Messages.showMessageDialog(
          project,
          InspectionsBundle.message("inspection.export.error.writing.to", fullPath),
          InspectionsBundle.message("inspection.export.results.error.title"),
          Messages.getErrorIcon()
        );
      }
    };
    ApplicationManager.getApplication().invokeLater(showError, ModalityState.NON_MODAL);
    throw new ProcessCanceledException();
  }
}

public static void triggerAction(final DataContext dataContext) {
    ApplicationManager.getApplication().invokeLater(() -> {
        final AnAction action = new ProjectRefreshAction();
        final AnActionEvent actionEvent = AnActionEvent.createFromAnAction(
            action,
            null,
            ActionPlaces.UNKNOWN,
            dataContext
        );
        action.actionPerformed(actionEvent);
    }, ModalityState.NON_MODAL);
}

public static void invokeLater(final Project p, final ModalityState state, final Runnable r) {
    if (isNoBackgroundMode()) {
        r.run();
    } else {
        ApplicationManager.getApplication().invokeLater(DisposeAwareRunnable.create(r, p), state);
    }
}

public static void invokeAndWait(final Project p, final ModalityState state, final Runnable r) {
    if (isNoBackgroundMode()) {
        r.run();
    } else {
        ApplicationManager.getApplication().invokeAndWait(DisposeAwareRunnable.create(r, p), state);
    }
}

private void hotSwapSessions( final List<DebuggerSession> sessions )
{
  HotSwapProgressImpl findClassesProgress = new HotSwapProgressImpl( getIjProject() );

  ApplicationManager.getApplication().executeOnPooledThread( () ->
  {
    final Map<DebuggerSession, Map<String, HotSwapFile>> modifiedClasses = scanForModifiedClassesWithProgress( sessions, findClassesProgress );

    final Application application = ApplicationManager.getApplication();
    if( modifiedClasses.isEmpty() )
    {
      final String message = DebuggerBundle.message( "status.hotswap.uptodate" );
      NotificationGroup.toolWindowGroup( "HotSwap", ToolWindowId.DEBUG ).createNotification( message, NotificationType.INFORMATION ).notify( getIjProject() );
      return;
    }

    application.invokeLater( () ->
    {
      if( !modifiedClasses.isEmpty() )
      {
        final HotSwapProgressImpl progress = new HotSwapProgressImpl( getIjProject() );
        if( modifiedClasses.keySet().size() == 1 )
        {
          //noinspection ConstantConditions
          progress.setSessionForActions( ContainerUtil.getFirstItem( modifiedClasses.keySet() ) );
        }
        application.executeOnPooledThread( () -> reloadModifiedClasses( modifiedClasses, progress ) );
      }
    }, ModalityState.NON_MODAL );
  } );
}

@Override
public void actionPerformed(AnActionEvent e) {
  final Module module = e.getData(LangDataKeys.MODULE);
  if (module == null) return;
  final Project project = module.getProject();
  final ListChooseByNameModel<SetupTask> model = new ListChooseByNameModel<SetupTask>(project, "Enter setup.py task name",
                                                                                      "No tasks found",
                                                                                      SetupTaskIntrospector.getTaskList(module));
  final ChooseByNamePopup popup = ChooseByNamePopup.createPopup(project, model, GotoActionBase.getPsiContext(e));
  popup.setShowListForEmptyPattern(true);

  popup.invoke(new ChooseByNamePopupComponent.Callback() {
    public void onClose() {
    }

    public void elementChosen(Object element) {
      if (element != null) {
        final SetupTask task = (SetupTask) element;
        ApplicationManager.getApplication().invokeLater(new Runnable() {
          public void run() {
            runSetupTask(task.getName(), module);
          }
        }, ModalityState.NON_MODAL);
      }
    }
  }, ModalityState.current(), false);

}

@Override
protected boolean test(@NotNull final String url) {
  HgIdentifyCommand identifyCommand = new HgIdentifyCommand(myProject);
  identifyCommand.setSource(url);
  HgCommandResult result = identifyCommand.execute(ModalityState.stateForComponent(getRootPane()));
  return result != null && result.getExitValue() == 0;
}

public void testTrueReorder() throws InvocationTargetException, InterruptedException {
  SwingUtilities.invokeLater(() -> {
    LaterInvocator.enterModal(myWindow1);
    ApplicationManager.getApplication().invokeLater(new MyRunnable("1"), ModalityState.NON_MODAL);
    SwingUtilities.invokeLater(ENTER_MODAL);
    LaterInvocator.leaveModal(myWindow1);
    SwingUtilities.invokeLater(LEAVE_MODAL);
    ApplicationManager.getApplication().invokeLater(new MyRunnable("2"), ModalityState.NON_MODAL);
  });
  flushSwingQueue();
  flushSwingQueue();
  checkOrder(2);
}

private static boolean wrapInWriteLater(Computable<Boolean> computable) {
    final boolean[] result = new boolean[1];

    ApplicationManager.getApplication().invokeAndWait(() ->
            result[0] = ApplicationManager.getApplication().runWriteAction(computable),
            ModalityState.defaultModalityState());

    return result[0];
}

public static String readFile(File file) {
    final String[] result = new String[1];
    ApplicationManager.getApplication().invokeAndWait(() ->
                    result[0] = ApplicationManager.getApplication().runReadAction((Computable<String>) () -> {
                        try {
                            BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(file), Const.charsets.UTF_8));
                            StringBuilder sb = new StringBuilder();
                            String line = br.readLine();

                            boolean isFirstLine = true;

                            while (line != null) {
                                if (isFirstLine) {
                                    isFirstLine = false;
                                    sb.append(line);
                                } else {
                                    sb.append("\n");
                                    sb.append(line);
                                }

                                line = br.readLine();
                            }

                            br.close();
                            return sb.toString();
                        } catch (Exception e) {
                            Logger.log("Error read file " + e.getMessage());
                            Logger.printStack(e);
                            return null;
                        }
                    })
            , ModalityState.defaultModalityState());
    return result[0];
}

public void testDoesNotInvokeWhenModal() throws InvocationTargetException, InterruptedException {
  UIUtil.invokeAndWaitIfNeeded((Runnable)() -> {
    LaterInvocator.enterModal(myWindow1);

    ApplicationManager.getApplication().invokeLater(ENTER_MODAL, ModalityState.NON_MODAL);
    ApplicationManager.getApplication().invokeLater(new MyRunnable("1"), ModalityState.NON_MODAL);
    LaterInvocator.leaveModal(myWindow1);
    flushSwingQueue();
    checkOrder(0);
    LaterInvocator.leaveModal(myWindow1);
    flushSwingQueue();
    checkOrder(1);
  });
}

private void updateButtons() {
  setOKActionEnabled(mySession.canExecute(myChanges, myCommitMessage));
  myOKButtonUpdateAlarm.cancelAllRequests();
  myOKButtonUpdateAlarm.addRequest(new Runnable() {
    public void run() {
      updateButtons();
    }
  }, 300, ModalityState.stateForComponent(myCenterPanel));
}

public void testRunQueuedRunnablesOnLeavingModality() {
  UIUtil.invokeAndWaitIfNeeded(new Runnable() {
    @Override
    public void run() {
      LaterInvocator.invokeLater(ENTER_MODAL, ModalityState.NON_MODAL);
      LaterInvocator.invokeLater(new MyRunnable("3"), ModalityState.NON_MODAL);
      flushSwingQueue();
      checkOrder(0);

      final ModalityState modalityState = ModalityState.stateForComponent(myWindow1);
      LaterInvocator.invokeLater(new MyRunnable("1") {
        @Override
        public void run() {
          super.run();
          checkOrder(1);
          LaterInvocator.invokeLater(new MyRunnable("2"), modalityState);
          checkOrder(1);
          LaterInvocator.leaveModal(myWindow1);
          checkOrder(2);
        }
      }, modalityState);
      flushSwingQueue(); // let "1" run

      flushSwingQueue(); // let "3" run
      checkOrder(3);
    }
  });
}

public void maybeRefresh(@NotNull ModalityState modalityState) {
  if (myBlockSyncOnFrameActivationCount.get() == 0 && mySettings.isSyncOnFrameActivation()) {
    RefreshQueue queue = RefreshQueue.getInstance();
    queue.cancelSession(myRefreshSessionId);

    RefreshSession session = queue.createSession(true, true, null, modalityState);
    session.addAllFiles(ManagingFS.getInstance().getLocalRoots());
    myRefreshSessionId = session.getId();
    session.launch();
  }
}

private void refreshImpl(final boolean useLastRevision) {
  new AbstractCalledLater(myVcs.getProject(), ModalityState.NON_MODAL) {
    public void run() {
      if (myInRefresh) return;
      myInRefresh = true;
      myTargetSelection = myDualView.getFlatView().getSelectedObjects();

      mySplitter.revalidate();
      mySplitter.repaint();

      myRefresherI.run(true, useLastRevision);
      columnSizesOnce();
    }
  }.callMe();
}

private void addUpdatingRequest(@NotNull final ModalityState modalityState) {
  if (myAlarm.isDisposed()) {
    return;
  }
  myAlarm.cancelAllRequests();
  myAlarm.addRequest(new Runnable() {
    @Override
    public void run() {
      startUpdatingAvds(modalityState);
    }
  }, 500, modalityState);
}

@Override
public void selectFile(@NotNull 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()));
}

private void _updateFilters() {
  try {
    updateFilters();
  }
  catch (ProcessCanceledException e) {
    DumbService.getInstance(myProject).smartInvokeLater(new Runnable() {
      @Override
      public void run() {
        _updateFilters();
      }
    }, ModalityState.NON_MODAL);
  }
}

public void projectOpened() {
  final ChangeListManager changeListManager = ChangeListManager.getInstance(myProject);
  changeListManager.addChangeListListener(myListener);
  Disposer.register(myProject, new Disposable() {
    public void dispose() {
      changeListManager.removeChangeListListener(myListener);
    }
  });
  if (ApplicationManager.getApplication().isHeadlessEnvironment()) return;
  myContent = ContentFactory.SERVICE.getInstance().createContent(createChangeViewComponent(), ChangesViewContentManager.LOCAL_CHANGES, false);
  myContent.setCloseable(false);
  myContentManager.addContent(myContent);

  scheduleRefresh();
  myConnection = myProject.getMessageBus().connect(myProject);
  myConnection.subscribe(RemoteRevisionsCache.REMOTE_VERSION_CHANGED, new Runnable() {
    public void run() {
      ApplicationManager.getApplication().invokeLater(new Runnable() {
        public void run() {
          refreshView();
        }
      }, ModalityState.NON_MODAL, myProject.getDisposed());
    }
  });
  // not sure we should turn it on on start (and pre-select smthg - rather heavy actions..)
  /*if (VcsConfiguration.getInstance(myProject).CHANGE_DETAILS_ON) {
    myToggleDetailsAction.actionPerformed(null);
  }*/
}

@Override
protected void notifyStart(final GenericMessage genericMessage) {
    DumbService.getInstance(myProject).smartInvokeLater(new Runnable() {
      public void run() {
        for (final IRemoteSuiteListener listener : m_suiteListeners) {
          listener.onInitialization(genericMessage);
        }
      }
    }, ModalityState.NON_MODAL);
}