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(); }