private static void addToHistory( final SMTestProxy.SMRootTestProxy root, TestConsoleProperties consoleProperties, Disposable parentDisposable) { final RunProfile configuration = consoleProperties.getConfiguration(); if (configuration instanceof RunConfiguration && !(consoleProperties instanceof ImportedTestConsoleProperties)) { final MySaveHistoryTask backgroundable = new MySaveHistoryTask(consoleProperties, root, (RunConfiguration) configuration); final BackgroundableProcessIndicator processIndicator = new BackgroundableProcessIndicator(backgroundable); Disposer.register( parentDisposable, new Disposable() { @Override public void dispose() { processIndicator.cancel(); backgroundable.dispose(); } }); Disposer.register(parentDisposable, processIndicator); ProgressManager.getInstance() .runProcessWithProgressAsynchronously(backgroundable, processIndicator); } }
public LayoutTreeComponent( ArtifactEditorImpl artifactsEditor, ComplexElementSubstitutionParameters substitutionParameters, ArtifactEditorContext context, Artifact originalArtifact, boolean sortElements) { myArtifactsEditor = artifactsEditor; mySubstitutionParameters = substitutionParameters; myContext = context; myOriginalArtifact = originalArtifact; mySortElements = sortElements; myTree = new LayoutTree(myArtifactsEditor); myTreeStructure = new LayoutTreeStructure(); myBuilder = new LayoutTreeBuilder(); Disposer.register(this, myTree); Disposer.register(this, myBuilder); myTree.addTreeSelectionListener( new TreeSelectionListener() { @Override public void valueChanged(TreeSelectionEvent e) { updatePropertiesPanel(false); } }); createPropertiesPanel(); myTreePanel = new JPanel(new BorderLayout()); myTreePanel.add(ScrollPaneFactory.createScrollPane(myTree), BorderLayout.CENTER); myTreePanel.add(myPropertiesPanelWrapper, BorderLayout.SOUTH); if (!ApplicationManager.getApplication().isUnitTestMode()) { DnDManager.getInstance().registerTarget(this, myTree); } }
public DaemonCodeAnalyzerImpl( Project project, DaemonCodeAnalyzerSettings daemonCodeAnalyzerSettings, EditorTracker editorTracker) { myProject = project; mySettings = daemonCodeAnalyzerSettings; myEditorTracker = editorTracker; myLastSettings = (DaemonCodeAnalyzerSettings) mySettings.clone(); myFileStatusMap = new FileStatusMap(myProject); myPassExecutorService = new PassExecutorService(myProject) { protected void afterApplyInformationToEditor( final TextEditorHighlightingPass pass, final FileEditor fileEditor, final ProgressIndicator updateProgress) { if (fileEditor instanceof TextEditor) { log(updateProgress, pass, "Apply "); Editor editor = ((TextEditor) fileEditor).getEditor(); repaintErrorStripeRenderer(editor); } } protected boolean isDisposed() { return myDisposed || super.isDisposed(); } }; Disposer.register(project, myPassExecutorService); Disposer.register(project, myFileStatusMap); }
public GridImpl(ViewContextEx viewContext, String sessionName) { myViewContext = viewContext; mySessionName = sessionName; Disposer.register(myViewContext, this); Disposer.register(this, myTopSplit); Placeholder left = new Placeholder(); myPlaceInGrid2Cell.put( PlaceInGrid.left, new GridCellImpl(myViewContext, this, left, PlaceInGrid.left)); Placeholder center = new Placeholder(); myPlaceInGrid2Cell.put( PlaceInGrid.center, new GridCellImpl(myViewContext, this, center, PlaceInGrid.center)); Placeholder right = new Placeholder(); myPlaceInGrid2Cell.put( PlaceInGrid.right, new GridCellImpl(myViewContext, this, right, PlaceInGrid.right)); Placeholder bottom = new Placeholder(); myPlaceInGrid2Cell.put( PlaceInGrid.bottom, new GridCellImpl(myViewContext, this, bottom, PlaceInGrid.bottom)); setContent(mySplitter); setOpaque(false); setFocusCycleRoot(true); myTopSplit.setFirstComponent(left); myTopSplit.setInnerComponent(center); myTopSplit.setLastComponent(right); myTopSplit.setMinSize(48); mySplitter.setFirstComponent(myTopSplit); mySplitter.setSecondComponent(bottom); }
public void testRegisterThenDisposeThenRegisterAgain() { Disposable disposable = Disposer.newDisposable(); Disposer.register(myRoot, disposable); Disposer.dispose(disposable); Disposer.register(myRoot, disposable); Disposer.register(disposable, Disposer.newDisposable()); }
public BaseTestsOutputConsoleView(final TestConsoleProperties properties) { myProperties = properties; myConsole = TextConsoleBuilderFactory.getInstance().createBuilder(properties.getProject()).getConsole(); myPrinter = new TestsOutputConsolePrinter(myConsole, properties); myProperties.setConsole(this); Disposer.register(this, myProperties); Disposer.register(this, myConsole); }
public void testDisposalOfParentess2() throws Throwable { Disposer.register(myFolder1, myLeaf1); Disposer.register(myFolder2, myLeaf2); Disposer.register(myFolder1, myFolder2); Disposer.dispose(myFolder1); assertDisposed(myFolder1); assertDisposed(myFolder2); assertDisposed(myLeaf1); assertDisposed(myLeaf2); }
public void testPostponedParentRegistration() throws Exception { Disposer.register(myFolder1, myLeaf1); Disposer.register(myLeaf1, myLeaf2); Disposer.register(myRoot, myFolder1); Disposer.dispose(myRoot); assertDisposed(myRoot); assertDisposed(myFolder1); assertDisposed(myLeaf1); assertDisposed(myLeaf2); }
public void testMustNotRegisterWithAlreadyDisposed() { Disposable disposable = Disposer.newDisposable(); Disposer.register(myRoot, disposable); Disposer.dispose(disposable); try { Disposer.register(disposable, Disposer.newDisposable()); fail("Must not be able to register with already disposed parent"); } catch (IncorrectOperationException ignored) { } }
public ThreeComponentsSplitter(boolean vertical) { myVerticalSplit = vertical; myShowDividerControls = false; myFirstDivider = new Divider(true); Disposer.register(this, myFirstDivider); myLastDivider = new Divider(false); Disposer.register(this, myLastDivider); myDividerWidth = 7; setOpaque(false); add(myFirstDivider); add(myLastDivider); }
public void testDirectCallOfDisposable() throws Exception { SelDisposable selfDisposable = new SelDisposable("root"); Disposer.register(myRoot, selfDisposable); Disposer.register(selfDisposable, myFolder1); Disposer.register(myFolder1, myFolder2); selfDisposable.dispose(); assertDisposed(selfDisposable); assertDisposed(myFolder1); assertDisposed(myFolder2); assertEquals(0, Disposer.getTree().getNodesInExecution().size()); }
@Override public void projectOpened() { assert !myInitialized : "Double Initializing"; myStatusBarUpdater = new StatusBarUpdater(myProject); Disposer.register(myProject, myStatusBarUpdater); myDaemonListeners = new DaemonListeners(myProject, this, myEditorTracker); Disposer.register(myProject, myDaemonListeners); reloadScopes(); myInitialized = true; myDisposed = false; myFileStatusMap.markAllFilesDirty(); }
public void initTerminal(final ToolWindow toolWindow) { LocalTerminalDirectRunner terminalRunner = LocalTerminalDirectRunner.createTerminalRunner(myProject); toolWindow.setToHideOnEmptyContent(true); Content content = createTerminalInContentPanel(terminalRunner, toolWindow); toolWindow.getContentManager().addContent(content); ((ToolWindowManagerEx) ToolWindowManager.getInstance(myProject)) .addToolWindowManagerListener( new ToolWindowManagerListener() { @Override public void toolWindowRegistered(@NotNull String id) {} @Override public void stateChanged() { ToolWindow window = ToolWindowManager.getInstance(myProject) .getToolWindow(TerminalToolWindowFactory.TOOL_WINDOW_ID); if (window != null) { boolean visible = window.isVisible(); if (visible && toolWindow.getContentManager().getContentCount() == 0) { initTerminal(window); } } } }); Disposer.register( myProject, new Disposable() { @Override public void dispose() { if (myTerminalWidget != null) { myTerminalWidget.dispose(); myTerminalWidget = null; } } }); if (myDockContainer == null) { myDockContainer = new TerminalDockContainer(toolWindow); Disposer.register(myProject, myDockContainer); DockManager.getInstance(myProject).register(myDockContainer); } }
public void testDisposalOrder() throws Exception { Disposer.register(myRoot, myFolder1); Disposer.register(myFolder1, myLeaf1); Disposer.register(myRoot, myFolder2); Disposer.dispose(myRoot); List<MyDisposable> expected = new ArrayList<>(); expected.add(myFolder2); expected.add(myLeaf1); expected.add(myFolder1); expected.add(myRoot); assertEquals(expected, myDisposedObjects); }
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 CoreModule( @NotNull Disposable parentDisposable, @NotNull Project project, String moduleFilePath) { super(project.getPicoContainer(), parentDisposable); myLifetime = parentDisposable; myProject = project; myPath = moduleFilePath; Extensions.instantiateArea(ExtensionAreas.IDEA_MODULE, this, null); CoreApplicationEnvironment.registerExtensionPoint( Extensions.getArea(this), ModuleExtension.EP_NAME, ModuleExtension.class); Disposer.register( parentDisposable, new Disposable() { @Override public void dispose() { Extensions.disposeArea(CoreModule.this); } }); initModuleExtensions(); final ModuleRootManagerImpl moduleRootManager = new ModuleRootManagerImpl( this, ProjectRootManagerImpl.getInstanceImpl(project), VirtualFilePointerManager.getInstance()) { @Override public void loadState(ModuleRootManagerState object) { loadState(object, false); } }; Disposer.register( parentDisposable, new Disposable() { @Override public void dispose() { moduleRootManager.disposeComponent(); } }); getPicoContainer().registerComponentInstance(ModuleRootManager.class, moduleRootManager); getPicoContainer() .registerComponentInstance( PathMacroManager.class, new ModulePathMacroManager(PathMacros.getInstance(), this)); getPicoContainer() .registerComponentInstance( ModuleFileIndex.class, new ModuleFileIndexImpl(this, DirectoryIndex.getInstance(project))); myModuleScopeProvider = createModuleScopeProvider(); }
public void focusLost(final FocusEvent e) { if (myPanel.getProject().isDisposed()) { myPanel.setContextComponent(null); myPanel.hideHint(); return; } final DialogWrapper dialog = DialogWrapper.findInstance(e.getOppositeComponent()); shouldFocusEditor = dialog != null; if (dialog != null) { Disposer.register( dialog.getDisposable(), new Disposable() { @Override public void dispose() { if (dialog.getExitCode() == DialogWrapper.CANCEL_EXIT_CODE) { shouldFocusEditor = false; } } }); } // required invokeLater since in current call sequence KeyboardFocusManager is not initialized // yet // but future focused component //noinspection SSBasedInspection SwingUtilities.invokeLater( new Runnable() { public void run() { processFocusLost(e); } }); }
private VirtualFilePointerContainer registerContainer( @NotNull Disposable parent, @NotNull final VirtualFilePointerContainerImpl virtualFilePointerContainer) { synchronized (myContainers) { myContainers.add(virtualFilePointerContainer); } Disposer.register( parent, new Disposable() { @Override public void dispose() { Disposer.dispose(virtualFilePointerContainer); boolean removed; synchronized (myContainers) { removed = myContainers.remove(virtualFilePointerContainer); } if (!ApplicationManager.getApplication().isUnitTestMode()) { assert removed; } } public String toString() { return "Disposing container " + virtualFilePointerContainer; } }); return virtualFilePointerContainer; }
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); } }
public EditorsSplitters( final FileEditorManagerImpl manager, DockManager dockManager, boolean createOwnDockableContainer) { super(new BorderLayout()); setOpaque(false); myManager = manager; myFocusWatcher = new MyFocusWatcher(); setFocusTraversalPolicy(new MyFocusTraversalPolicy()); setTransferHandler(new MyTransferHandler()); clear(); if (createOwnDockableContainer) { DockableEditorTabbedContainer dockable = new DockableEditorTabbedContainer(myManager.getProject(), this, false); Disposer.register(manager.getProject(), dockable); dockManager.register(dockable); } UISettings.getInstance() .addUISettingsListener( new UISettingsListener() { @Override public void uiSettingsChanged(UISettings source) { updateBackground(); } }, manager.getProject()); updateBackground(); }
protected void init() { if (myWrapper != null) return; myProcessor = createProcessor(); String dialogGroupKey = myProcessor.getContextUserData(DiffUserDataKeys.DIALOG_GROUP_KEY); if (dialogGroupKey == null) dialogGroupKey = "DiffContextDialog"; myWrapper = new WindowWrapperBuilder( DiffUtil.getWindowMode(myHints), new MyPanel(myProcessor.getComponent())) .setProject(myProject) .setParent(myHints.getParent()) .setDimensionServiceKey(dialogGroupKey) .setOnShowCallback( new Runnable() { @Override public void run() { myProcessor.updateRequest(); myProcessor .requestFocus(); // TODO: not needed for modal dialogs. Make a flag in // WindowWrapperBuilder ? } }) .build(); myWrapper.setImage(ImageLoader.loadFromResource("/diff/Diff.png")); Disposer.register(myWrapper, myProcessor); new DumbAwareAction() { public void actionPerformed(final AnActionEvent e) { myWrapper.close(); } }.registerCustomShortcutSet(CommonShortcuts.getCloseActiveWindow(), myProcessor.getComponent()); }
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 UpdateInfoTree showUpdateProjectInfo( UpdatedFiles updatedFiles, String displayActionName, ActionInfo actionInfo, boolean canceled) { if (!myProject.isOpen() || myProject.isDisposed()) return null; ContentManager contentManager = getContentManager(); if (contentManager == null) { return null; // content manager is made null during dispose; flag is set later } final UpdateInfoTree updateInfoTree = new UpdateInfoTree(contentManager, myProject, updatedFiles, displayActionName, actionInfo); Content content = ContentFactory.SERVICE .getInstance() .createContent( updateInfoTree, canceled ? VcsBundle.message( "toolwindow.title.update.action.canceled.info", displayActionName) : VcsBundle.message("toolwindow.title.update.action.info", displayActionName), true); Disposer.register(content, updateInfoTree); ContentsUtil.addContent(contentManager, content, true); ToolWindowManager.getInstance(myProject).getToolWindow(ToolWindowId.VCS).activate(null); updateInfoTree.expandRootChildren(); return updateInfoTree; }
protected JComponent createCenterPanel() { myEditor = new OptionsEditor(myProject, myGroups, myPreselected); myEditor .getContext() .addColleague( new OptionsEditorColleague.Adapter() { @Override public ActionCallback onModifiedAdded(final Configurable configurable) { updateStatus(); return new ActionCallback.Done(); } @Override public ActionCallback onModifiedRemoved(final Configurable configurable) { updateStatus(); return new ActionCallback.Done(); } @Override public ActionCallback onErrorsChanged() { updateStatus(); return new ActionCallback.Done(); } }); Disposer.register(myDisposable, myEditor); return myEditor; }
@Override public void addTracker( @NotNull final String fileUrl, @NotNull final VirtualFileListener listener, final boolean fromRefreshOnly, @NotNull Disposable parentDisposable) { getSet(fileUrl, myAllTrackers).add(listener); if (!fromRefreshOnly) { getSet(fileUrl, myNonRefreshTrackers).add(listener); } Disposer.register( parentDisposable, new Disposable() { @Override public void dispose() { removeListener(fileUrl, listener, myAllTrackers); if (!fromRefreshOnly) { removeListener(fileUrl, listener, myNonRefreshTrackers); } } }); }
public ExternalAnnotationsManagerImpl( @NotNull final Project project, final PsiManager psiManager) { super(psiManager); myBus = project.getMessageBus(); final MessageBusConnection connection = myBus.connect(project); connection.subscribe( ProjectTopics.PROJECT_ROOTS, new ModuleRootAdapter() { @Override public void rootsChanged(ModuleRootEvent event) { dropCache(); } }); final MyVirtualFileListener fileListener = new MyVirtualFileListener(); VirtualFileManager.getInstance().addVirtualFileListener(fileListener); Disposer.register( myPsiManager.getProject(), new Disposable() { @Override public void dispose() { VirtualFileManager.getInstance().removeVirtualFileListener(fileListener); } }); }
EditorsSplitters( final FileEditorManagerImpl manager, DockManager dockManager, boolean createOwnDockableContainer) { super(new BorderLayout()); myManager = manager; myFocusWatcher = new MyFocusWatcher(); setFocusTraversalPolicy(new MyFocusTraversalPolicy()); clear(); if (createOwnDockableContainer) { DockableEditorTabbedContainer dockable = new DockableEditorTabbedContainer(myManager.getProject(), this, false); Disposer.register(manager.getProject(), dockable); dockManager.register(dockable); } KeymapManagerListener keymapListener = new KeymapManagerListener() { @Override public void activeKeymapChanged(Keymap keymap) { invalidate(); repaint(); } }; KeymapManager.getInstance().addKeymapManagerListener(keymapListener, this); }
public static void setApplication( Application instance, Getter<FileTypeRegistry> fileTypeRegistryGetter, Getter<EncodingRegistry> encodingRegistryGetter, @NotNull Disposable parent) { final Application old = ourApplication; final Getter<FileTypeRegistry> oldFileTypeRegistry = FileTypeRegistry.ourInstanceGetter; final Getter<EncodingRegistry> oldEncodingRegistry = EncodingRegistry.ourInstanceGetter; Disposer.register( parent, new Disposable() { @Override public void dispose() { if (old != null) { // to prevent NPEs in threads still running setApplication(old); //noinspection AssignmentToStaticFieldFromInstanceMethod FileTypeRegistry.ourInstanceGetter = oldFileTypeRegistry; EncodingRegistry.ourInstanceGetter = oldEncodingRegistry; } } }); setApplication(instance); FileTypeRegistry.ourInstanceGetter = fileTypeRegistryGetter; EncodingRegistry.ourInstanceGetter = encodingRegistryGetter; }
public CvsTabbedWindow(Project project) { myProject = project; Disposer.register( project, new Disposable() { public void dispose() { if (myOutput != null) { EditorFactory.getInstance().releaseEditor(myOutput); myOutput = null; } if (myErrorsView != null) { myErrorsView.dispose(); myErrorsView = null; } LOG.assertTrue(!myIsDisposed); try { if (!myIsInitialized) return; ToolWindowManager toolWindowManager = ToolWindowManager.getInstance(myProject); toolWindowManager.unregisterToolWindow(ToolWindowId.CVS); } finally { myIsDisposed = true; } } }); }
public LanguageConsoleImpl( Project project, String title, LightVirtualFile lightFile, boolean initComponents) { myProject = project; myTitle = title; myVirtualFile = lightFile; EditorFactory editorFactory = EditorFactory.getInstance(); myHistoryFile = new LightVirtualFile(getTitle() + ".history.txt", FileTypes.PLAIN_TEXT, ""); myEditorDocument = FileDocumentManager.getInstance().getDocument(lightFile); reparsePsiFile(); assert myEditorDocument != null; myConsoleEditor = (EditorEx) editorFactory.createEditor(myEditorDocument, myProject); myConsoleEditor.addFocusListener(myFocusListener); myCurrentEditor = myConsoleEditor; myHistoryViewer = (EditorEx) editorFactory.createViewer( ((EditorFactoryImpl) editorFactory).createDocument(true), myProject); myUpdateQueue = new MergingUpdateQueue("ConsoleUpdateQueue", 300, true, null); Disposer.register(this, myUpdateQueue); // action shortcuts are not yet registered ApplicationManager.getApplication() .invokeLater( new Runnable() { @Override public void run() { installEditorFactoryListener(); } }); if (initComponents) { initComponents(); } }