/** * Show the dialog if needed * * @param project the project * @param root the vcs root * @return true if showing is not needed or operation completed successfully */ public static boolean showIfNeeded(final Project project, final VirtualFile root) { final ArrayList<String> files = new ArrayList<String>(); try { scanFiles(project, root, files); final AtomicBoolean rc = new AtomicBoolean(true); if (!files.isEmpty()) { UIUtil.invokeAndWaitIfNeeded( new Runnable() { public void run() { GitUpdateLocallyModifiedDialog d = new GitUpdateLocallyModifiedDialog(project, root, files); d.show(); rc.set(d.isOK()); } }); if (rc.get()) { if (!files.isEmpty()) { revertFiles(project, root, files); } } } return rc.get(); } catch (final VcsException e) { UIUtil.invokeAndWaitIfNeeded( new Runnable() { public void run() { GitUIUtil.showOperationError(project, e, "Checking for locally modified files"); } }); return false; } }
@Override protected JPanel processSplitter( @NotNull Element splitterElement, Element firstChild, Element secondChild, final JPanel context) { if (context == null) { final boolean orientation = "vertical".equals(splitterElement.getAttributeValue("split-orientation")); final float proportion = Float.valueOf(splitterElement.getAttributeValue("split-proportion")).floatValue(); final JPanel firstComponent = process(firstChild, null); final JPanel secondComponent = process(secondChild, null); final Ref<JPanel> panelRef = new Ref<JPanel>(); UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { JPanel panel = new JPanel(new BorderLayout()); panel.setOpaque(false); Splitter splitter = new OnePixelSplitter(orientation, proportion, 0.1f, 0.9f); panel.add(splitter, BorderLayout.CENTER); splitter.setFirstComponent(firstComponent); splitter.setSecondComponent(secondComponent); panelRef.set(panel); } }); return panelRef.get(); } final Ref<JPanel> firstComponent = new Ref<JPanel>(); final Ref<JPanel> secondComponent = new Ref<JPanel>(); UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { if (context.getComponent(0) instanceof Splitter) { Splitter splitter = (Splitter) context.getComponent(0); firstComponent.set((JPanel) splitter.getFirstComponent()); secondComponent.set((JPanel) splitter.getSecondComponent()); } else { firstComponent.set(context); secondComponent.set(context); } } }); process(firstChild, firstComponent.get()); process(secondChild, secondComponent.get()); return context; }
@Before public void setUp() throws Exception { UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { try { final IdeaTestFixtureFactory fixtureFactory = IdeaTestFixtureFactory.getFixtureFactory(); myTempDirTestFixture = fixtureFactory.createTempDirTestFixture(); myTempDirTestFixture.setUp(); myClientRoot = new File(myTempDirTestFixture.getTempDirPath(), "clientroot"); myClientRoot.mkdir(); initProject(myClientRoot, ExternalChangesDetectionVcsTest.this.getTestName()); myVcs = new MockAbstractVcs(myProject); myVcs.setChangeProvider(new MyMockChangeProvider()); myVcsManager = (ProjectLevelVcsManagerImpl) ProjectLevelVcsManager.getInstance(myProject); myVcsManager.registerVcs(myVcs); myVcsManager.setDirectoryMapping("", myVcs.getName()); myLFS = LocalFileSystem.getInstance(); myChangeListManager = ChangeListManager.getInstance(myProject); myVcsDirtyScopeManager = VcsDirtyScopeManager.getInstance(myProject); } catch (Exception e) { throw new RuntimeException(e); } } }); }
@Override protected void tearDown() throws Exception { UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { try { if (useJps()) { CompilerWorkspaceConfiguration.getInstance(getProject()).USE_COMPILE_SERVER = false; ApplicationManagerEx.getApplicationEx().doNotSave(true); new WriteCommandAction(getProject()) { @Override protected void run(Result result) throws Throwable { final JavaAwareProjectJdkTableImpl jdkTable = JavaAwareProjectJdkTableImpl.getInstanceEx(); jdkTable.removeJdk(jdkTable.getInternalJdk()); } }.execute(); } myMainOutput.tearDown(); myMainOutput = null; GroovyCompilerTestCase.super.tearDown(); } catch (Exception e) { throw new RuntimeException(e); } } }); }
@BeforeMethod protected void setUp(final Method testMethod) throws Exception { // setting hg executable String exec = System.getenv(HG_EXECUTABLE_PATH); if (exec != null) { myClientBinaryPath = new File(exec); } if (exec == null || !myClientBinaryPath.exists()) { final File pluginRoot = new File(PluginPathManager.getPluginHomePath(HgVcs.VCS_NAME)); myClientBinaryPath = new File(pluginRoot, "testData/bin"); } HgVcs.setTestHgExecutablePath(myClientBinaryPath.getPath()); myMainRepo = initRepositories(); myProjectDir = new File(myMainRepo.getDirFixture().getTempDirPath()); UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { try { initProject(myProjectDir, testMethod.getName()); activateVCS(HgVcs.VCS_NAME); } catch (Exception e) { e.printStackTrace(); } } }); myChangeListManager = new HgTestChangeListManager(myProject); myTraceClient = true; doActionSilently(VcsConfiguration.StandardConfirmation.ADD); doActionSilently(VcsConfiguration.StandardConfirmation.REMOVE); }
private List<String> runCompiler(final Consumer<ErrorReportingCallback> runnable) { final Semaphore semaphore = new Semaphore(); semaphore.down(); final ErrorReportingCallback callback = new ErrorReportingCallback(semaphore); UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { try { if (useJps()) { getProject().save(); CompilerTestUtil.saveSdkTable(); File ioFile = VfsUtil.virtualToIoFile(myModule.getModuleFile()); if (!ioFile.exists()) { getProject().save(); assert ioFile.exists() : "File does not exist: " + ioFile.getPath(); } } runnable.consume(callback); } catch (Exception e) { throw new RuntimeException(e); } } }); // tests run in awt while (!semaphore.waitFor(100)) { if (SwingUtilities.isEventDispatchThread()) { UIUtil.dispatchAllInvocationEvents(); } } callback.throwException(); return callback.getMessages(); }
private void taskFinished(@NotNull final DumbModeTask prevTask) { UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { if (myProject.isDisposed()) return; Disposer.dispose(prevTask); while (true) { if (myUpdatesQueue.isEmpty()) { updateFinished(); return; } DumbModeTask queuedTask = myUpdatesQueue.pullFirst(); ProgressIndicatorEx indicator = myProgresses.get(queuedTask); if (indicator.isCanceled()) { Disposer.dispose(queuedTask); continue; } startBackgroundProcess(queuedTask, indicator); return; } } }); }
public void openFiles() { if (mySplittersElement != null) { initializeProgress(); final JPanel comp = myUIBuilder.process(mySplittersElement, getTopPanel()); UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { if (comp != null) { removeAll(); add(comp, BorderLayout.CENTER); mySplittersElement = null; } // clear empty splitters for (EditorWindow window : getWindows()) { if (window.getEditors().length == 0) { for (EditorWindow sibling : window.findSiblings()) { sibling.unsplit(false); } } } } }); } }
private void setDumbMode(final boolean dumb) { UIUtil.invokeAndWaitIfNeeded( new Runnable() { public void run() { DumbServiceImpl.getInstance(_project).setDumb(dumb); } }); }
static int alert(final String msg) { UIUtil.invokeAndWaitIfNeeded( new Runnable() { public void run() { Messages.showMessageDialog(msg, "Injection Plugin", Messages.getInformationIcon()); } }); return 0; }
private static VirtualFile refreshAndFindFile(final File file) { return UIUtil.invokeAndWaitIfNeeded( new Computable<VirtualFile>() { @Override public VirtualFile compute() { return LocalFileSystem.getInstance().refreshAndFindFileByIoFile(file); } }); }
private void notifyLoaded() { UIUtil.invokeAndWaitIfNeeded( (Runnable) () -> { for (Runnable loadingFinishedListener : myLoadingFinishedListeners) { loadingFinishedListener.run(); } }); }
protected void disposeSession(final DebuggerSession debuggerSession) throws InterruptedException, InvocationTargetException { UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { debuggerSession.dispose(); } }); }
private static void testMemory(final String msg) { if (!TEST_MEMORY_USAGE) return; UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { MessageDialogBuilder.yesNo(msg, msg).show(); } }); }
public void addTextToEditor(final String text) { UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { getConsoleView().setInputText(text); PsiDocumentManager.getInstance(getProject()).commitAllDocuments(); } }); }
protected void clearAllBreakpoints() { UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { XDebuggerTestUtil.removeAllBreakpoints(getProject()); } }); }
public void drainQueuedUsageNodes() { assert !ApplicationManager.getApplication().isDispatchThread() : Thread.currentThread(); UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { myTransferToEDTQueue.drain(); } }); }
public void saveInCache(@NotNull TIntObjectHashMap<T> details) { UIUtil.invokeAndWaitIfNeeded( (Runnable) () -> details.forEachEntry( (key, value) -> { myCache.put(key, value); return true; })); }
protected void resolveDependenciesAndImport() { UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { myProjectsManager.waitForResolvingCompletion(); myProjectsManager.performScheduledImportInTests(); } }); }
public static void executeOnEdt(boolean synchronous, @NotNull Runnable task) { if (synchronous) { if (ApplicationManager.getApplication().isDispatchThread()) { task.run(); } else { UIUtil.invokeAndWaitIfNeeded(task); } } else { UIUtil.invokeLaterIfNeeded(task); } }
protected void exec(final String command) throws InterruptedException { waitForReady(); myCommandSemaphore.acquire(1); UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { myConsoleView.executeInConsole(command); } }); }
/** * Toggles breakpoint * * @param file getScriptPath() or path to script * @param line starting with 0 */ protected void toggleBreakpoint(final String file, final int line) { UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { doToggleBreakpoint(file, line); } }); addOrRemoveBreakpoint(file, line); }
/** * Check and process locally modified files * * @param root the project root * @param ex the exception holder */ protected boolean checkLocallyModified(final VirtualFile root) throws VcsException { final Ref<Boolean> cancelled = new Ref<Boolean>(false); UIUtil.invokeAndWaitIfNeeded( new Runnable() { public void run() { if (!GitUpdateLocallyModifiedDialog.showIfNeeded(myProject, root)) { cancelled.set(true); } } }); return !cancelled.get(); }
protected static void setFileText(final PsiFile file, final String barText) throws IOException { UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { try { VfsUtil.saveText(ObjectUtils.assertNotNull(file.getVirtualFile()), barText); } catch (IOException e) { throw new RuntimeException(e); } } }); }
protected void waitForReadingCompletion() { UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { try { myProjectsManager.waitForReadingCompletion(); } catch (Exception e) { throw new RuntimeException(e); } } }); }
private void setPromptInner(final String prompt) { UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { myConsoleEditor.setPrefixTextAndAttributes( prompt, ConsoleViewContentType.USER_INPUT.getAttributes()); if (myPanel.isVisible()) { queueUiUpdate(false); } } }); }
private void disposeConsole() throws InterruptedException { if (myCommunication != null) { UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { try { myCommunication.close(); } catch (Exception e) { e.printStackTrace(); } myCommunication = null; } }); } disposeConsoleProcess(); if (!myContentDescriptorRef.isNull()) { UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { Disposer.dispose(myContentDescriptorRef.get()); } }); } if (myConsoleView != null) { new WriteAction() { @Override protected void run(@NotNull Result result) throws Throwable { Disposer.dispose(myConsoleView); myConsoleView = null; } }.execute(); } }
protected void undo() { UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { final TestDialog oldTestDialog = Messages.setTestDialog(TestDialog.OK); try { UndoManager.getInstance(myProject).undo(null); } finally { Messages.setTestDialog(oldTestDialog); } } }); }
@Override protected void tearDown() throws Exception { UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { try { VfsUtilTest.super.tearDown(); } catch (Exception e) { throw new RuntimeException(e); } } }); }
private CompilationLog compile(final ParameterizedRunnable<CompileStatusNotification> action) { final Ref<CompilationLog> result = Ref.create(null); final Semaphore semaphore = new Semaphore(); UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { semaphore.down(); CompilerManagerImpl.testSetup(); final CompileStatusNotification callback = new CompileStatusNotification() { @Override public void finished( boolean aborted, int errors, int warnings, CompileContext compileContext) { try { if (aborted) { Assert.fail("compilation aborted"); } result.set( new CompilationLog( CompilerManagerImpl.getPathsToRecompile(), CompilerManagerImpl.getPathsToDelete(), compileContext.getMessages(CompilerMessageCategory.ERROR), compileContext.getMessages(CompilerMessageCategory.WARNING))); } finally { semaphore.up(); } } }; if (useExternalCompiler()) { myProject.save(); CompilerTestUtil.saveSdkTable(); CompilerTestUtil.scanSourceRootsToRecompile(myProject); } action.run(callback); } }); long start = System.currentTimeMillis(); while (!semaphore.waitFor(10)) { if (System.currentTimeMillis() - start > 60 * 1000) { throw new RuntimeException("timeout"); } UIUtil.dispatchAllInvocationEvents(); } UIUtil.dispatchAllInvocationEvents(); return result.get(); }