@Nullable public CvsTabbedWindow openTabbedWindow(final CvsHandler output) { if (ApplicationManager.getApplication().isUnitTestMode()) return null; if (myProject != null && myProject.isDefault()) return null; if (myProject != null) { if (myConfiguration != null && myConfiguration.SHOW_OUTPUT && !myIsQuietOperation) { if (ApplicationManager.getApplication().isDispatchThread()) { connectToOutput(output); } else { ApplicationManager.getApplication() .invokeAndWait( new Runnable() { public void run() { connectToOutput(output); } }, ModalityState.defaultModalityState()); } } if (!myProject.isDisposed()) { return CvsTabbedWindow.getInstance(myProject); } } return null; }
@Override public void addMessageToConsoleWindow(final String message, final TextAttributes attributes) { if (!Registry.is("vcs.showConsole")) { return; } if (StringUtil.isEmptyOrSpaces(message)) { return; } ApplicationManager.getApplication() .invokeLater( new Runnable() { @Override public void run() { // for default and disposed projects the ContentManager is not available. if (myProject.isDisposed() || myProject.isDefault()) return; final ContentManager contentManager = getContentManager(); if (contentManager == null) { myPendingOutput.add(Pair.create(message, attributes)); } else { getOrCreateConsoleContent(contentManager); myEditorAdapter.appendString(message, attributes); } } }, ModalityState.defaultModalityState()); }
public 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", myPresentableName), title); if (password == null) { return; } if (password.equals(myConfiguration.getPassword())) { confirmed.set(true); return; } Messages.showErrorDialog( CloudBundle.getText("cloud.undeploy.confirm.password.incorrect"), title); } } }, ModalityState.defaultModalityState()); return confirmed.get(); }
@Override protected byte[] key(@Nullable final Project project) throws PasswordSafeException { ApplicationEx application = (ApplicationEx) ApplicationManager.getApplication(); if (!isTestMode() && application.isHeadlessEnvironment()) { throw new MasterPasswordUnavailableException( "The provider is not available in headless environment"); } if (key.get() == null) { if (isPasswordEncrypted()) { try { String s = decryptPassword(database.getPasswordInfo()); setMasterPassword(s); } catch (PasswordSafeException e) { // ignore exception and ask password } } if (key.get() == null) { final Ref<PasswordSafeException> ex = new Ref<PasswordSafeException>(); if (application.holdsReadLock()) { throw new IllegalStateException( "Access from read action is not allowed, because it might lead to a deadlock."); } application.invokeAndWait( new Runnable() { public void run() { if (key.get() == null) { try { if (isTestMode()) { throw new MasterPasswordUnavailableException( "Master password must be specified in test mode."); } if (database.isEmpty()) { if (!ResetPasswordDialog.newPassword(project, MasterKeyPasswordSafe.this)) { throw new MasterPasswordUnavailableException( "Master password is required to store passwords in the database."); } } else { MasterPasswordDialog.askPassword(project, MasterKeyPasswordSafe.this); } } catch (PasswordSafeException e) { ex.set(e); } catch (Exception e) { //noinspection ThrowableInstanceNeverThrown ex.set( new MasterPasswordUnavailableException( "The problem with retrieving the password", e)); } } } }, ModalityState.defaultModalityState()); //noinspection ThrowableResultOfMethodCallIgnored if (ex.get() != null) { throw ex.get(); } } } return this.key.get(); }
private void showMergeDialog(@NotNull final Collection<VirtualFile> initiallyUnmergedFiles) { ApplicationManager.getApplication() .invokeAndWait( () -> { MergeProvider mergeProvider = new GitMergeProvider(myProject, myParams.reverse); myVcsHelper.showMergeDialog( new ArrayList<>(initiallyUnmergedFiles), mergeProvider, myParams.myMergeDialogCustomizer); }, ModalityState.defaultModalityState()); }
/** * Opens an error dialog with the specified title. Ensures that the error dialog is opened on the * UI thread. * * @param message The message to be displayed. * @param title The title of the error dialog to be displayed */ public static void showErrorDialog(final String message, @NotNull final String title) { if (ApplicationManager.getApplication().isDispatchThread()) { Messages.showErrorDialog(message, title); } else { ApplicationManager.getApplication() .invokeLater( new Runnable() { @Override public void run() { Messages.showErrorDialog(message, title); } }, ModalityState.defaultModalityState()); } }
@Override protected void loadLibraries() { if (!ThreadUtils.isEventDispatchThread()) { ApplicationManager.getApplication() .invokeAndWait( new Runnable() { @Override public void run() { ProjectLibraryManager.super.loadLibraries(); } }, ModalityState.defaultModalityState()); } else { super.loadLibraries(); } }
public static VirtualFile waitForTheFile(final String path) { final VirtualFile[] file = new VirtualFile[1]; final Application app = ApplicationManager.getApplication(); Runnable action = new Runnable() { @Override public void run() { app.runWriteAction( new Runnable() { @Override public void run() { file[0] = LocalFileSystem.getInstance().refreshAndFindFileByPath(path); } }); } }; app.invokeAndWait(action, ModalityState.defaultModalityState()); return file[0]; }
@Nullable public static VirtualFile waitForTheFile(@Nullable final String path) { if (path == null) return null; final VirtualFile[] file = new VirtualFile[1]; final Application app = ApplicationManager.getApplication(); Runnable action = new Runnable() { public void run() { app.runWriteAction( new Runnable() { public void run() { file[0] = LocalFileSystem.getInstance().refreshAndFindFileByPath(path); } }); } }; if (app.isDispatchThread()) { action.run(); } else { app.invokeAndWait(action, ModalityState.defaultModalityState()); } return file[0]; }
public EmptyProgressIndicator() { this(ModalityState.defaultModalityState()); }
public static void generate(GeneratingCompiler compiler, final CompileContext context) { if (context == null) { return; } final Set<Module> affectedModules = new HashSet<Module>(); Collections.addAll(affectedModules, context.getCompileScope().getAffectedModules()); ApplicationManager.getApplication() .invokeAndWait( new Runnable() { @Override public void run() { for (Module module : affectedModules) { if (module.isDisposed() || module.getProject().isDisposed()) { continue; } final AndroidFacet facet = AndroidFacet.getInstance(module); if (facet != null) { AndroidCompileUtil.createGenModulesAndSourceRoots(facet); } } } }, ModalityState.defaultModalityState()); List<GeneratingCompiler.GenerationItem> itemsToGenerate = new ArrayList<GeneratingCompiler.GenerationItem>(); for (GeneratingCompiler.GenerationItem item : compiler.getGenerationItems(context)) { if (affectedModules.contains(item.getModule())) { itemsToGenerate.add(item); } } GeneratingCompiler.GenerationItem[] items = itemsToGenerate.toArray(new GeneratingCompiler.GenerationItem[itemsToGenerate.size()]); final boolean[] run = {true}; final VirtualFile[] files = getFilesToCheckReadonlyStatus(items); if (files.length > 0) { ApplicationManager.getApplication() .invokeAndWait( new Runnable() { @Override public void run() { ApplicationManager.getApplication() .runReadAction( new Runnable() { @Override public void run() { final Project project = context.getProject(); run[0] = !project.isDisposed() && ReadonlyStatusHandler.ensureFilesWritable(project, files); } }); } }, ModalityState.defaultModalityState()); } if (run[0]) { compiler.generate(context, items, null); } }
@NotNull static ActionCallback invokeLater(@NotNull Runnable runnable, @NotNull Condition<?> expired) { ModalityState modalityState = ModalityState.defaultModalityState(); return invokeLater(runnable, modalityState, expired); }
public void startPLugin() { if (hasRanPreviously() && isGuidewireApp()) { ExceptionUtil.showError( GosuBundle.message("error.plugin_disabled"), GosuBundle.message("error.plugin_disabled.description")); return; } for (ITypeSystemStartupContributor contributor : getStartupContributors()) { String message = contributor.accepts(_project); if (message != null) { ExceptionUtil.showInfo(GosuBundle.message("info.plugin.not.started"), message); return; } } ApplicationManager.getApplication() .invokeAndWait( new Runnable() { public void run() { ApplicationManager.getApplication() .runWriteAction( new Runnable() { public void run() { // pre -startup try { for (ITypeSystemStartupContributor pluginListener : getStartupContributors()) { pluginListener.beforeTypesystemStartup(_project); } } catch (Exception e) { reportStartupError(e); return; } // !PW leaks reference to GosuLoader, if we ever want to support clean // unloading of plugin _applicationConnection = ApplicationManager.getApplication().getMessageBus().connect(); setDumbMode(true); try { startTypeSystem(); initGosuPlugin(); for (ITypeSystemStartupContributor pluginListener : getStartupContributors()) { pluginListener.afterTypesystemStartup(_project); } System.out.println("Initialized Gosu with IJ Project: " + _project); } catch (Throwable e) { reportStartupError(e); System.out.println("¿prolbem?"); } finally { setDumbMode(false); } } }); } }, ModalityState.defaultModalityState()); }
public CvsOperationExecutor(Project project) { this(true, project, ModalityState.defaultModalityState()); }
public static void invokeAndWait(Project p, Runnable r) { invokeAndWait(p, ModalityState.defaultModalityState(), r); }
private void applyInformationToEditorsLater( @NotNull final FileEditor fileEditor, @NotNull final TextEditorHighlightingPass pass, @NotNull final DaemonProgressIndicator updateProgress, @NotNull final AtomicInteger threadsToStartCountdown) { ApplicationManager.getApplication() .invokeLater( (DumbAwareRunnable) () -> { if (isDisposed() || myProject.isDisposed()) { updateProgress.cancel(); } if (updateProgress.isCanceled()) { log(updateProgress, pass, " is canceled during apply, sorry"); return; } Document document = pass.getDocument(); try { if (fileEditor.getComponent().isDisplayable() || ApplicationManager.getApplication().isUnitTestMode()) { pass.applyInformationToEditor(); FileStatusMap fileStatusMap = DaemonCodeAnalyzerEx.getInstanceEx(myProject).getFileStatusMap(); if (document != null) { fileStatusMap.markFileUpToDate(document, pass.getId()); } log(updateProgress, pass, " Applied"); } } catch (ProcessCanceledException e) { log(updateProgress, pass, "Error " + e); throw e; } catch (RuntimeException e) { VirtualFile file = document == null ? null : FileDocumentManager.getInstance().getFile(document); FileType fileType = file == null ? null : file.getFileType(); String message = "Exception while applying information to " + fileEditor + "(" + fileType + ")"; log(updateProgress, pass, message + e); throw new RuntimeException(message, e); } if (threadsToStartCountdown.decrementAndGet() == 0) { log(updateProgress, pass, "Stopping "); updateProgress.stopIfRunning(); } else { log( updateProgress, pass, "Finished but there are passes in the queue: " + threadsToStartCountdown.get()); } }, Registry.is("ide.perProjectModality") ? ModalityState.defaultModalityState() : ModalityState.stateForComponent(fileEditor.getComponent())); }
/** * The most general execution method. * * @param sync Set to <code>true</code> to make the calling thread wait for the task execution. * @param modal If <code>true</code>, the task will be modal with a modal progress dialog. If * false, the task will be executed in background. <code>modal</code> implies <code>sync * </code>, i.e. if modal then sync doesn't matter: you'll wait anyway. * @param resultHandler Handle the result. * @see #execute(boolean) */ public void execute(boolean sync, boolean modal, final GitTaskResultHandler resultHandler) { final Object LOCK = new Object(); final AtomicBoolean completed = new AtomicBoolean(); if (modal) { final ModalTask task = new ModalTask(myProject, myHandler, myTitle) { @Override public void onSuccess() { commonOnSuccess(LOCK, resultHandler); completed.set(true); } @Override public void onCancel() { commonOnCancel(LOCK, resultHandler); completed.set(true); } }; GuiUtils.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { ProgressManager.getInstance().run(task); } }, ModalityState.defaultModalityState()); } else { final BackgroundableTask task = new BackgroundableTask(myProject, myHandler, myTitle) { @Override public void onSuccess() { commonOnSuccess(LOCK, resultHandler); completed.set(true); } @Override public void onCancel() { commonOnCancel(LOCK, resultHandler); completed.set(true); } }; if (myProgressIndicator == null) { GitVcs.runInBackground(task); } else { task.runAlone(); } } if (sync) { while (!completed.get()) { try { synchronized (LOCK) { LOCK.wait(50); } } catch (InterruptedException e) { LOG.info(e); } } } }