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