private void reset() {
ApplicationManager.getApplication().assertIsDispatchThread();
myUsageNodes.clear();
myIsFirstVisibleUsageFound = false;
myModel.reset();
if (!myPresentation.isDetachedMode()) {
SwingUtilities.invokeLater(
new Runnable() {
@Override
public void run() {
if (isDisposed) return;
TreeUtil.expand(myTree, 2);
}
});
}
}
private void rulesChanged() {
ApplicationManager.getApplication().assertIsDispatchThread();
final ArrayList<UsageState> states = new ArrayList<UsageState>();
captureUsagesExpandState(new TreePath(myTree.getModel().getRoot()), states);
final List<Usage> allUsages = new ArrayList<Usage>(myUsageNodes.keySet());
Collections.sort(allUsages, USAGE_COMPARATOR);
final Set<Usage> excludedUsages = getExcludedUsages();
reset();
myBuilder.setGroupingRules(getActiveGroupingRules(myProject));
myBuilder.setFilteringRules(getActiveFilteringRules(myProject));
ApplicationManager.getApplication()
.runReadAction(
new Runnable() {
@Override
public void run() {
for (Usage usage : allUsages) {
if (!usage.isValid()) {
continue;
}
if (usage instanceof MergeableUsage) {
((MergeableUsage) usage).reset();
}
appendUsage(usage);
}
}
});
excludeUsages(excludedUsages.toArray(new Usage[excludedUsages.size()]));
if (myCentralPanel != null) {
setupCentralPanel();
}
SwingUtilities.invokeLater(
new Runnable() {
@Override
public void run() {
if (isDisposed) return;
restoreUsageExpandState(states);
updateImmediately();
}
});
}
@NotNull
public ModalityState getModalityStateForComponent(@NotNull Component c) {
Window window = c instanceof Window ? (Window) c : SwingUtilities.windowForComponent(c);
if (window == null) return getNoneModalityState(); // ?
return LaterInvocator.modalityStateForWindow(window);
}
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();
}