private static void closeFiles() throws IOException {
if (myFlushingFuture != null) {
myFlushingFuture.cancel(false);
myFlushingFuture = null;
}
if (myNames != null) {
myNames.close();
myNames = null;
}
if (myAttributes != null) {
Disposer.dispose(myAttributes);
myAttributes = null;
}
if (myContents != null) {
Disposer.dispose(myContents);
myContents = null;
}
if (myRecords != null) {
markClean();
myRecords.close();
myRecords = null;
}
ourInitialized = false;
}
@Override
public void disposeComponent() {
Disposer.dispose(myConnection);
Disposer.dispose(myAlarm);
VirtualFileManager.getInstance().removeVirtualFileListener(myFilesListener);
myLastHandledGoPathSourcesRoots.clear();
myLastHandledExclusions.clear();
LocalFileSystem.getInstance().removeWatchedRoots(myWatchedRequests);
myWatchedRequests.clear();
}
@Override
public void disposeComponent() {
ApplicationManager.getApplication().assertWriteAccessAllowed();
Disposer.dispose(myChangedFilesAlarm);
if (myDefaultProject != null) {
Disposer.dispose(myDefaultProject);
myDefaultProject = null;
myDefaultProjectWasDisposed = true;
}
}
@TestOnly
public void cleanupAfterTest(boolean dispose) {
if (!myProject.isOpen()) return;
stopProcess(false);
if (dispose) {
projectClosed();
Disposer.dispose(myStatusBarUpdater);
myStatusBarUpdater = null;
Disposer.dispose(myDaemonListeners);
myDaemonListeners = null;
}
setUpdateByTimerEnabled(false);
waitForTermination();
}
public void dispose() {
myDisposed = true;
myDiffUpdater.dispose();
Disposer.dispose(myScrollSupport);
Disposer.dispose(myData);
myPanel.cancelScrollEditors();
JComponent component = myPanel.getBottomComponent();
if (component instanceof Disposable) {
Disposer.dispose((Disposable) component);
}
myPanel.setBottomComponent(null);
myPanel.setDataProvider(null);
myPanel.setScrollingPanel(null);
}
public void testOverrideParentDisposable() throws Exception {
Disposer.register(myFolder1, myLeaf1);
Disposer.register(myFolder2, myFolder1);
Disposer.register(myRoot, myFolder1);
Disposer.dispose(myFolder2);
assertDisposed(myFolder2);
assertFalse(myLeaf1.isDisposed());
assertFalse(myFolder1.isDisposed());
Disposer.dispose(myRoot);
assertDisposed(myFolder1);
assertDisposed(myLeaf1);
}
public void dispose() {
if (myComponent instanceof Disposable) {
Disposer.dispose(((Disposable) myComponent));
}
myComponent = null;
myFocusRequest = null;
myManager = null;
clearUserData();
if (myDisposer != null) {
Disposer.dispose(myDisposer);
myDisposer = null;
}
}
public static void closeAndDisposeProjectAndCheckThatNoOpenProjects(
@NotNull Project projectToClose, @NotNull List<Throwable> exceptions) {
try {
ProjectManagerEx projectManager = ProjectManagerEx.getInstanceEx();
if (projectManager instanceof ProjectManagerImpl) {
for (Project project : projectManager.closeTestProject(projectToClose)) {
exceptions.add(
new IllegalStateException(
"Test project is not disposed: "
+ project
+ ";\n created in: "
+ getCreationPlace(project)));
try {
((ProjectManagerImpl) projectManager).closeProject(project, false, true, false);
} catch (Throwable e) {
exceptions.add(e);
}
}
}
} catch (Throwable e) {
exceptions.add(e);
} finally {
AccessToken token = WriteAction.start();
try {
Disposer.dispose(projectToClose);
} catch (Throwable e) {
exceptions.add(e);
} finally {
token.finish();
}
}
}
private void layoutPanel() {
if (myUsagePreviewPanel != null) {
Disposer.dispose(myUsagePreviewPanel);
}
removeAll();
JScrollPane pane = ScrollPaneFactory.createScrollPane(myTree);
if (isPreview()) {
pane.setBorder(IdeBorderFactory.createBorder(SideBorder.LEFT | SideBorder.RIGHT));
boolean vertical =
myToolWindow.getAnchor() == ToolWindowAnchor.LEFT
|| myToolWindow.getAnchor() == ToolWindowAnchor.RIGHT;
Splitter splitter =
new Splitter(
vertical, UsageViewSettings.getInstance().PREVIEW_USAGES_SPLITTER_PROPORTIONS);
splitter.setFirstComponent(pane);
myUsagePreviewPanel = new UsagePreviewPanel(myProject, new UsageViewPresentation());
myUsagePreviewPanel.setBorder(IdeBorderFactory.createBorder(SideBorder.LEFT));
Disposer.register(this, myUsagePreviewPanel);
splitter.setSecondComponent(myUsagePreviewPanel);
add(splitter, BorderLayout.CENTER);
} else {
pane.setBorder(IdeBorderFactory.createBorder(SideBorder.LEFT));
add(pane, BorderLayout.CENTER);
}
add(createToolbar().getComponent(), BorderLayout.WEST);
myTree.getParent().setBackground(UIManager.getColor("Tree.background"));
revalidate();
}
@Override
public void deactivate() {
if (null != myHgRemoteStatusUpdater) {
myHgRemoteStatusUpdater.deactivate();
myHgRemoteStatusUpdater = null;
}
if (null != myHgCurrentBranchStatusUpdater) {
myHgCurrentBranchStatusUpdater.deactivate();
myHgCurrentBranchStatusUpdater = null;
}
if (null != myStatusWidget) {
myStatusWidget.deactivate();
myStatusWidget = null;
}
if (null != myIncomingWidget) {
myIncomingWidget.deactivate();
myIncomingWidget = null;
}
if (null != myOutgoingWidget) {
myOutgoingWidget.deactivate();
myOutgoingWidget = null;
}
if (messageBusConnection != null) {
messageBusConnection.disconnect();
}
if (myVFSListener != null) {
Disposer.dispose(myVFSListener);
myVFSListener = null;
}
super.deactivate();
}
public void testEditJUnitConfiguration() throws ConfigurationException {
if (PlatformTestUtil.COVERAGE_ENABLED_BUILD) return;
PsiClass testA = findTestA(getModule2());
JUnitConfiguration configuration = createConfiguration(testA);
JUnitConfigurable editor = new JUnitConfigurable(myProject);
try {
Configurable configurable = new RunConfigurationConfigurableAdapter(editor, configuration);
configurable.reset();
final EditorTextFieldWithBrowseButton component =
((LabeledComponent<EditorTextFieldWithBrowseButton>)
editor.getTestLocation(JUnitConfigurationModel.CLASS))
.getComponent();
assertEquals(testA.getQualifiedName(), component.getText());
PsiClass otherTest = findClass(getModule2(), "test2.Test2");
component.setText(otherTest.getQualifiedName());
configurable.apply();
assertEquals(otherTest.getName(), configuration.getName());
String specialName = "My name";
configuration.setName(specialName);
configuration.setNameChangedByUser(true);
configurable.reset();
component.setText(testA.getQualifiedName());
configurable.apply();
assertEquals(specialName, configuration.getName());
} finally {
Disposer.dispose(editor);
}
}
final void dispose() {
removeAll();
Disposer.dispose(myHeader);
myHeader = null;
myProject = null;
}
public void waitProcess(@NotNull final ProcessHandler processHandler) {
Alarm alarm = new Alarm(Alarm.ThreadToUse.SHARED_THREAD, getTestRootDisposable());
final boolean[] isRunning = {true};
alarm.addRequest(
new Runnable() {
@Override
public void run() {
boolean b;
synchronized (isRunning) {
b = isRunning[0];
}
if (b) {
processHandler.destroyProcess();
LOG.error("process was running over " + myTimeout / 1000 + " seconds. Interrupted. ");
}
}
},
myTimeout);
processHandler.waitFor();
synchronized (isRunning) {
isRunning[0] = false;
}
Disposer.dispose(alarm);
}
private boolean disposeSelf() {
myDisposeInProgress = true;
final CommandProcessor commandProcessor = CommandProcessor.getInstance();
final Ref<Boolean> canClose = new Ref<Boolean>(Boolean.TRUE);
for (final Project project : ProjectManagerEx.getInstanceEx().getOpenProjects()) {
try {
commandProcessor.executeCommand(
project,
new Runnable() {
public void run() {
canClose.set(ProjectUtil.closeAndDispose(project));
}
},
ApplicationBundle.message("command.exit"),
null);
} catch (Throwable e) {
LOG.error(e);
}
if (!canClose.get()) {
myDisposeInProgress = false;
return false;
}
}
Disposer.dispose(this);
Disposer.assertIsEmpty();
return true;
}
private boolean checkNoDifferenceAndNotify(
DiffPanel diffPanel, DiffRequest data, final Window window, final boolean showMessage) {
if (!diffPanel.hasDifferences() && !data.getHints().contains(HINT_ALLOW_NO_DIFFERENCES)) {
DiffManagerImpl manager = (DiffManagerImpl) DiffManager.getInstance();
if (!Comparing.equal(manager.getComparisonPolicy(), ComparisonPolicy.DEFAULT)) {
ComparisonPolicy oldPolicy = manager.getComparisonPolicy();
manager.setComparisonPolicy(ComparisonPolicy.DEFAULT);
Disposable parentDisposable = Disposer.newDisposable();
DiffPanel maybeDiffPanel =
DiffManagerImpl.createDiffPanel(data, window, parentDisposable, this);
manager.setComparisonPolicy(oldPolicy);
boolean hasDiffs = maybeDiffPanel.hasDifferences();
Disposer.dispose(parentDisposable);
if (hasDiffs) return false;
}
if (!showMessage) {
return true;
}
return !askForceOpenDiff(data);
}
return false;
}
@Nullable
ProjectBuilder runModuleWizard(Component dialogParent, boolean anImport) {
AbstractProjectWizard wizard;
if (anImport) {
wizard = ImportModuleAction.selectFileAndCreateWizard(myProject, dialogParent);
if (wizard == null) return null;
if (wizard.getStepCount() == 0) {
ProjectBuilder builder = wizard.getProjectBuilder();
Disposer.dispose(wizard.getDisposable());
return builder;
}
} else {
wizard = new NewProjectWizard(myProject, dialogParent, this);
}
if (wizard.showAndGet()) {
final ProjectBuilder builder = wizard.getProjectBuilder();
if (builder instanceof ModuleBuilder) {
final ModuleBuilder moduleBuilder = (ModuleBuilder) builder;
if (moduleBuilder.getName() == null) {
moduleBuilder.setName(wizard.getProjectName());
}
if (moduleBuilder.getModuleFilePath() == null) {
moduleBuilder.setModuleFilePath(wizard.getModuleFilePath());
}
}
if (!builder.validate(myProject, myProject)) {
return null;
}
return wizard.getProjectBuilder();
}
return null;
}
@Override
public final void actionPerformed(final AnActionEvent event) {
final DataContext dataContext = event.getDataContext();
final HierarchyBrowserBaseEx browser =
(HierarchyBrowserBaseEx) dataContext.getData(myBrowserDataKey);
if (browser == null) return;
final PsiElement selectedElement = browser.getSelectedElement();
if (selectedElement == null || !browser.isApplicableElement(selectedElement)) return;
final String currentViewType = browser.myCurrentViewType;
Disposer.dispose(browser);
final HierarchyProvider provider =
BrowseHierarchyActionBase.findProvider(
myProviderLanguageExtension,
selectedElement,
selectedElement.getContainingFile(),
event.getDataContext());
final HierarchyBrowser newBrowser =
BrowseHierarchyActionBase.createAndAddToPanel(
selectedElement.getProject(), provider, selectedElement);
ApplicationManager.getApplication()
.invokeLater(
() ->
((HierarchyBrowserBaseEx) newBrowser)
.changeView(correctViewType(browser, currentViewType)));
}
void doRefresh(boolean currentBuilderOnly) {
if (currentBuilderOnly) LOG.assertTrue(myCurrentViewType != null);
if (!isValidBase()) return;
if (getCurrentBuilder() == null) return; // seems like we are in the middle of refresh already
final Ref<Pair<List<Object>, List<Object>>> storedInfo =
new Ref<Pair<List<Object>, List<Object>>>();
if (myCurrentViewType != null) {
final HierarchyTreeBuilder builder = getCurrentBuilder();
storedInfo.set(builder.storeExpandedAndSelectedInfo());
}
final PsiElement element = mySmartPsiElementPointer.getElement();
if (element == null || !isApplicableElement(element)) {
return;
}
final String currentViewType = myCurrentViewType;
if (currentBuilderOnly) {
Disposer.dispose(getCurrentBuilder());
} else {
disposeBuilders();
}
setHierarchyBase(element);
validate();
ApplicationManager.getApplication()
.invokeLater(
() -> {
changeView(currentViewType);
final HierarchyTreeBuilder builder = getCurrentBuilder();
builder.restoreExpandedAndSelectedInfo(storedInfo.get());
});
}
private void adjustPositionForLookup(@NotNull Lookup lookup) {
if (!myHint.isVisible() || myEditor.isDisposed()) {
Disposer.dispose(this);
return;
}
IdeTooltip tooltip = myHint.getCurrentIdeTooltip();
if (tooltip != null) {
JRootPane root = myEditor.getComponent().getRootPane();
if (root != null) {
Point p = tooltip.getShowingPoint().getPoint(root.getLayeredPane());
if (lookup.isPositionedAboveCaret()) {
if (Position.above == tooltip.getPreferredPosition()) {
myHint.pack();
myHint.updatePosition(Position.below);
myHint.updateLocation(p.x, p.y + tooltip.getPositionChangeY());
}
} else {
if (Position.below == tooltip.getPreferredPosition()) {
myHint.pack();
myHint.updatePosition(Position.above);
myHint.updateLocation(p.x, p.y - tooltip.getPositionChangeY());
}
}
}
}
}
private void finishCompletionProcess(boolean disposeOffsetMap) {
cancel();
ApplicationManager.getApplication().assertIsDispatchThread();
Disposer.dispose(myQueue);
LookupManager.getInstance(getProject()).removePropertyChangeListener(myLookupManagerListener);
CompletionProgressIndicator currentCompletion =
CompletionServiceImpl.getCompletionService().getCurrentCompletion();
LOG.assertTrue(currentCompletion == this, currentCompletion + "!=" + this);
CompletionServiceImpl.assertPhase(
CompletionPhase.BgCalculation.class,
CompletionPhase.ItemsCalculated.class,
CompletionPhase.Synchronous.class,
CompletionPhase.CommittingDocuments.class);
if (CompletionServiceImpl.getCompletionPhase() instanceof CompletionPhase.CommittingDocuments) {
LOG.assertTrue(
CompletionServiceImpl.getCompletionPhase().indicator != null,
CompletionServiceImpl.getCompletionPhase());
((CompletionPhase.CommittingDocuments) CompletionServiceImpl.getCompletionPhase()).replaced =
true;
}
CompletionServiceImpl.setCompletionPhase(CompletionPhase.NoCompletion);
if (disposeOffsetMap) {
disposeOffsetMaps();
}
}
static void setOrRefreshErrorStripeRenderer(
@NotNull EditorMarkupModel editorMarkupModel,
@NotNull Project project,
@NotNull Document document,
PsiFile file) {
ApplicationManager.getApplication().assertIsDispatchThread();
if (!editorMarkupModel.isErrorStripeVisible()
|| !DaemonCodeAnalyzer.getInstance(project).isHighlightingAvailable(file)) {
return;
}
ErrorStripeRenderer renderer = editorMarkupModel.getErrorStripeRenderer();
if (renderer instanceof TrafficLightRenderer) {
TrafficLightRenderer tlr = (TrafficLightRenderer) renderer;
tlr.refresh();
((EditorMarkupModelImpl) editorMarkupModel).repaintVerticalScrollBar();
if (tlr.myFile == null || tlr.myFile.isValid()) return;
Disposer.dispose(tlr);
}
EditorImpl editor = (EditorImpl) editorMarkupModel.getEditor();
if (!editor.isDisposed()) {
renderer = new TrafficLightRenderer(project, document, file);
Disposer.register(editor.getDisposable(), (Disposable) renderer);
editorMarkupModel.setErrorStripeRenderer(renderer);
}
}
@Override
public void disposeUIResources() {
if (!myUiInitialized) return;
final PropertiesComponent propertiesComponent = PropertiesComponent.getInstance(myProject);
propertiesComponent.setValue("project.structure.last.edited", myUiState.lastEditedConfigurable);
propertiesComponent.setValue(
"project.structure.proportion", String.valueOf(myUiState.proportion));
propertiesComponent.setValue(
"project.structure.side.proportion", String.valueOf(myUiState.sideProportion));
myWasUiDisposed = true;
myUiState.proportion = mySplitter.getProportion();
saveSideProportion();
myContext.getDaemonAnalyzer().stop();
for (Configurable each : myName2Config) {
each.disposeUIResources();
}
myContext.clear();
myName2Config.clear();
myModuleConfigurator.getFacetsConfigurator().clearMaps();
Disposer.dispose(myErrorsComponent);
myUiInitialized = false;
}
@Override
public void removeNotify() {
super.removeNotify();
if (myDisposable != null && !Disposer.isDisposed(myDisposable)) {
Disposer.dispose(myDisposable);
}
}
@Override
public void hideHint() {
super.hideHint();
if (myDisposable != null) {
Disposer.dispose(myDisposable);
}
}
@Override
protected void tearDown() throws Exception {
try {
Disposer.dispose(myTestRootDisposable);
cleanupSwingDataStructures();
cleanupDeleteOnExitHookList();
} finally {
if (shouldContainTempFiles()) {
FileUtil.resetCanonicalTempPathCache(ORIGINAL_TEMP_DIR);
if (ourPathToKeep != null && FileUtil.isAncestor(myTempDir, ourPathToKeep, false)) {
File[] files = new File(myTempDir).listFiles();
if (files != null) {
for (File file : files) {
if (!FileUtil.pathsEqual(file.getPath(), ourPathToKeep)) {
FileUtil.delete(file);
}
}
}
} else {
FileUtil.delete(new File(myTempDir));
}
}
}
UIUtil.removeLeakingAppleListeners();
super.tearDown();
}
public void deinstallNorthComponents() {
for (IdeRootPaneNorthExtension northComponent : myNorthComponents) {
myNorthPanel.remove(northComponent.getComponent());
Disposer.dispose(northComponent);
}
myNorthComponents.clear();
}
@Override
public void disposeUIResources() {
try {
if (!myDisposeCompleted) {
try {
super.disposeUIResources();
Disposer.dispose(myDisposable);
if (myRootSchemesPanel != null) {
myRootSchemesPanel.disposeUIResources();
}
} finally {
myDisposeCompleted = true;
}
}
} finally {
mySubPanelFactories = null;
myInitResetCompleted = false;
myInitResetInvoked = false;
myRevertChangesCompleted = false;
myApplyCompleted = false;
myRootSchemesPanel = null;
}
}
public void testModulesSelector() throws ConfigurationException {
if (PlatformTestUtil.COVERAGE_ENABLED_BUILD) return;
Module module1 = getModule1();
Module module2 = getModule2();
JUnitConfigurable editor = new JUnitConfigurable(myProject);
try {
JUnitConfiguration configuration = createConfiguration(findTestA(module2));
editor.getComponent(); // To get all the watchers installed.
Configurable configurable = new RunConfigurationConfigurableAdapter(editor, configuration);
JComboBox comboBox = editor.getModulesComponent();
configurable.reset();
assertFalse(configurable.isModified());
assertEquals(module2.getName(), ((Module) comboBox.getSelectedItem()).getName());
assertEquals(
ModuleManager.getInstance(myProject).getModules().length + 1,
comboBox.getModel().getSize()); // no module
comboBox.setSelectedItem(module1);
assertTrue(configurable.isModified());
configurable.apply();
assertFalse(configurable.isModified());
assertEquals(
Collections.singleton(module1), ContainerUtilRt.newHashSet(configuration.getModules()));
} finally {
Disposer.dispose(editor);
}
}
@Override
public void dispose() {
saveLocation(getBounds());
super.dispose();
Disposer.dispose(myScreen);
WelcomeFrame.resetInstance();
}
@Override
public void cancel(InputEvent e) {
super.cancel(e);
disposeChildren();
Disposer.dispose(this);
getStep().canceled();
}
