下面列出了javax.swing.text.html.ImageView#consulo.disposer.Disposable 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
public static void addPropertyListener(final AbstractProperty<Boolean> property,
final TestFrameworkPropertyListener<Boolean> propertyListener,
final TestFrameworkRunningModel model,
final boolean sendValue) {
final TestConsoleProperties properties = model.getProperties();
if (sendValue) {
properties.addListenerAndSendValue(property, propertyListener);
}
else {
properties.addListener(property, propertyListener);
}
Disposer.register(model, new Disposable() {
public void dispose() {
properties.removeListener(property, propertyListener);
}
});
}
public RecentStringInterner(@Nonnull Disposable parentDisposable) {
final int stripes = 16;
//noinspection unchecked
myInterns = new SLRUCache[stripes];
myStripeLocks = new Lock[myInterns.length];
int capacity = 8192;
for (int i = 0; i < myInterns.length; ++i) {
myInterns[i] = new SLRUCache<String, String>(capacity / stripes, capacity / stripes) {
@Nonnull
@Override
public String createValue(String key) {
return key;
}
@Override
protected void putToProtectedQueue(String key, @Nonnull String value) {
super.putToProtectedQueue(value, value);
}
};
myStripeLocks[i] = new ReentrantLock();
}
assert Integer.highestOneBit(stripes) == stripes;
myStripeMask = stripes - 1;
LowMemoryWatcher.register(this::clear, parentDisposable);
}
public static void disposeWithEditor(@Nonnull Editor editor, @Nonnull Disposable disposable) {
ApplicationManager.getApplication().assertIsDispatchThread();
if (Disposer.isDisposed(disposable)) return;
if (editor.isDisposed()) {
Disposer.dispose(disposable);
return;
}
// for injected editors disposal will happen only when host editor is disposed,
// but this seems to be the best we can do (there are no notifications on disposal of injected editor)
Editor hostEditor = editor instanceof EditorWindow ? ((EditorWindow)editor).getDelegate() : editor;
EditorFactory.getInstance().addEditorFactoryListener(new EditorFactoryAdapter() {
@Override
public void editorReleased(@Nonnull EditorFactoryEvent event) {
if (event.getEditor() == hostEditor) {
Disposer.dispose(disposable);
}
}
}, disposable);
}
public static void adjustFocusTraversal(@Nonnull Disposable disposable) {
if (!SystemInfo.isMacOSSnowLeopard) return;
final AWTEventListener listener = new AWTEventListener() {
@Override
public void eventDispatched(AWTEvent event) {
if (event instanceof KeyEvent && ((KeyEvent)event).getKeyCode() == KeyEvent.VK_TAB && (!(event.getSource() instanceof JTextComponent)) && (!(event.getSource() instanceof JList)) && !isFullKeyboardAccessEnabled())
((KeyEvent)event).consume();
}
};
Disposer.register(disposable, new Disposable() {
@Override
public void dispose() {
Toolkit.getDefaultToolkit().removeAWTEventListener(listener);
}
});
Toolkit.getDefaultToolkit().addAWTEventListener(listener, AWTEvent.KEY_EVENT_MASK);
}
public AsyncPopupImpl(@Nullable Project project, @Nullable WizardPopup parent, @Nonnull AsyncPopupStep<Object> step, @Nullable Object parentValue) {
super(project, parent, step);
if (!(parent instanceof NextStepHandler)) throw new IllegalArgumentException("parent must be NextStepHandler");
myCallBackParent = (NextStepHandler)parent;
myParentValue = parentValue;
myFuture = ApplicationManager.getApplication().executeOnPooledThread(step);
myAlarm = new Alarm(this);
myAlarm.addRequest(this, 200);
Disposer.register(this, new Disposable() {
@Override
public void dispose() {
if (!myFuture.isCancelled() && !myFuture.isDone()) {
myFuture.cancel(false);
}
}
});
}
public static void install(DiffContent content, EditorSource source, DiffSidesContainer container) {
final Editor editor = source.getEditor();
Project project = container.getProject();
if (project == null || editor == null) {
return;
}
final MouseLineNumberListener listener = new MouseLineNumberListener(content, editor, container, project);
editor.addEditorMouseListener(listener.myMouseListener);
editor.addEditorMouseMotionListener(listener.myMouseMotionListener);
source.addDisposable(new Disposable() {
public void dispose() {
editor.removeEditorMouseListener(listener.myMouseListener);
editor.removeEditorMouseMotionListener(listener.myMouseMotionListener);
}
});
}
public static AutoCloseable cancelJobOnDisposal(Disposable thisDisposable, Job job, boolean weaklyReferencedJob) {
ExpirableConstrainedExecution.RunOnce runOnce = new ExpirableConstrainedExecution.RunOnce();
Disposable child = () -> {
runOnce.invoke(() -> {
job.cancel();
});
};
Disposable childRef = !weaklyReferencedJob ? child : new WeakReferenceDisposableWrapper(child);
if (!tryRegisterDisposable(thisDisposable, childRef)) {
Disposer.dispose(childRef); // runs disposableBlock()
return () -> {
};
}
else {
Consumer<Throwable> completionHandler = new Consumer<Throwable>() {
@SuppressWarnings("unused")
Disposable hardRefToChild = child; // transitive: job -> completionHandler -> child
@Override
public void accept(Throwable t) {
runOnce.invoke(() -> {
Disposer.dispose(childRef);
});
}
};
Disposable jobCompletionUnregisteringHandle = job.invokeOnCompletion(completionHandler);
return () -> {
jobCompletionUnregisteringHandle.dispose();
completionHandler.accept(null);
};
}
}
protected void runRegisteredDisposables() {
resetHighlighters();
for (Disposable runnable : myDisposables) {
Disposer.dispose(runnable);
}
myDisposables.clear();
}
public final void register(@Nonnull Disposable parent, @Nonnull Disposable child) {
if (parent == child) throw new IllegalArgumentException("Cannot register to itself: " + parent);
synchronized (treeLock) {
Object wasDisposed = getDisposalInfo(parent);
if (wasDisposed != null) {
throw new IncorrectOperationException("Sorry but parent: " + parent + " has already been disposed " + "(see the cause for stacktrace) so the child: " + child + " will never be disposed",
wasDisposed instanceof Throwable ? (Throwable)wasDisposed : null);
}
if (isDisposing(parent)) {
throw new IncorrectOperationException("Sorry but parent: " + parent + " is being disposed so the child: " + child + " will never be disposed");
}
myDisposedObjects.remove(child); // if we dispose thing and then register it back it means it's not disposed anymore
ObjectNode parentNode = getNode(parent);
if (parentNode == null) parentNode = createNodeFor(parent, null);
ObjectNode childNode = getNode(child);
if (childNode == null) {
childNode = createNodeFor(child, parentNode);
}
else {
ObjectNode oldParent = childNode.getParent();
if (oldParent != null) {
oldParent.removeChild(childNode);
}
}
myRootObjects.remove(child);
checkWasNotAddedAlready(parentNode, childNode);
parentNode.addChild(childNode);
}
}
public void projectOpened() {
final ChangeListManager changeListManager = ChangeListManager.getInstance(myProject);
changeListManager.addChangeListListener(myListener);
Disposer.register(myProject, new Disposable() {
public void dispose() {
changeListManager.removeChangeListListener(myListener);
}
});
if (ApplicationManager.getApplication().isHeadlessEnvironment()) return;
myContent = new MyChangeViewContent(createChangeViewComponent(), ChangesViewContentManager.LOCAL_CHANGES, false);
myContent.setCloseable(false);
myContentManager.addContent(myContent);
scheduleRefresh();
myProject.getMessageBus().connect().subscribe(RemoteRevisionsCache.REMOTE_VERSION_CHANGED, new Runnable() {
public void run() {
ApplicationManager.getApplication().invokeLater(new Runnable() {
public void run() {
refreshView();
}
}, ModalityState.NON_MODAL, myProject.getDisposed());
}
});
myDetailsOn = VcsConfiguration.getInstance(myProject).LOCAL_CHANGES_DETAILS_PREVIEW_SHOWN;
changeDetails();
}
public ChangeListTodosPanel(Project project,TodoPanelSettings settings, Content content){
super(project,settings,false,content);
ChangeListManager changeListManager = ChangeListManager.getInstance(project);
final MyChangeListManagerListener myChangeListManagerListener = new MyChangeListManagerListener();
changeListManager.addChangeListListener(myChangeListManagerListener);
Disposer.register(this, new Disposable() {
@Override
public void dispose() {
ChangeListManager.getInstance(myProject).removeChangeListListener(myChangeListManagerListener);
}
});
myAlarm = new Alarm(Alarm.ThreadToUse.POOLED_THREAD, this);
}
public DiffPanelState(ContentChangeListener changeListener,
Project project,
int diffDividerPolygonsOffset,
@Nonnull Disposable parentDisposable) {
super(project, changeListener, parentDisposable);
myDiffDividerPolygonsOffset = diffDividerPolygonsOffset;
}
public synchronized void flushCaches() {
for (Disposable disposable : myCacheDisposables) {
try {
disposable.dispose();
}
catch (Throwable e) {
LOG.info(e);
}
}
myCacheDisposables.clear();
myGenericCachesMap.clear();
myCompilerToCacheMap.clear();
}
public VcsLogPersistentIndex(@Nonnull Project project,
@Nonnull VcsLogStorage hashMap,
@Nonnull VcsLogProgress progress,
@Nonnull Map<VirtualFile, VcsLogProvider> providers,
@Nonnull FatalErrorHandler fatalErrorsConsumer,
@Nonnull Disposable disposableParent) {
myHashMap = hashMap;
myProject = project;
myProgress = progress;
myProviders = providers;
myFatalErrorsConsumer = fatalErrorsConsumer;
myRoots = ContainerUtil.newLinkedHashSet();
for (Map.Entry<VirtualFile, VcsLogProvider> entry : providers.entrySet()) {
if (VcsLogProperties.get(entry.getValue(), VcsLogProperties.SUPPORTS_INDEXING)) {
myRoots.add(entry.getKey());
}
}
myUserRegistry = (VcsUserRegistryImpl)ServiceManager.getService(myProject, VcsUserRegistry.class);
myIndexStorage = createIndexStorage(fatalErrorsConsumer, calcLogId(myProject, providers));
for (VirtualFile root : myRoots) {
myNumberOfTasks.put(root, new AtomicInteger());
}
Disposer.register(disposableParent, this);
}
@Nonnull
@Override
public AddModuleDependencyTabContext createTabContext(@Nonnull Disposable parent,
@Nonnull ClasspathPanel panel,
@Nonnull StructureConfigurableContext context) {
return new ProjectLibraryTabContext(panel, context);
}
private Module addModule(final String name) {
final ModifiableModuleModel model = getModuleManager().getModifiableModel();
final Module module = model.newModule(name, myProject.getBaseDir().getPath());
commitModel(model);
disposeOnTearDown(new Disposable() {
@Override
public void dispose() {
if (!module.isDisposed()) {
getModuleManager().disposeModule(module);
}
}
});
return module;
}
@Override
public void addListener(final Listener listener, Disposable parent) {
myDockingListeners.add(listener);
Disposer.register(parent, new Disposable() {
@Override
public void dispose() {
myDockingListeners.remove(listener);
}
});
}
@RequiredUIAccess
@Override
public void setErrorStripeRenderer(ErrorStripeRenderer renderer) {
assertIsDispatchThread();
if (myErrorStripeRenderer instanceof Disposable) {
Disposer.dispose((Disposable)myErrorStripeRenderer);
}
myErrorStripeRenderer = renderer;
//try to not cancel tooltips here, since it is being called after every writeAction, even to the console
//HintManager.getInstance().getTooltipController().cancelTooltips();
}
@RequiredUIAccess
public NewProjectPanel(@Nonnull Disposable parentDisposable, @Nullable Project project, @Nullable VirtualFile moduleHome) {
super(parentDisposable);
myModuleHome = moduleHome;
setOKActionText(IdeBundle.message("button.create"));
setCancelText(CommonBundle.message("button.cancel"));
}
private ToolWindow doRegisterToolWindow(final String id, @Nullable Disposable parentDisposable) {
MockToolWindow tw = new MockToolWindow(myProject);
myToolWindows.put(id, tw);
if (parentDisposable != null) {
Disposer.register(parentDisposable, () -> unregisterToolWindow(id));
}
return tw;
}
public void addChangeListener(@Nonnull final ChangeListener listener, @Nonnull final Disposable parent) {
if (myConsole instanceof ObservableConsoleView) {
((ObservableConsoleView)myConsole).addChangeListener(listener, parent);
} else {
throw new UnsupportedOperationException(myConsole.getClass().getName());
}
}
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);
}
@Override
public void installFileCompletion(@Nonnull TextBox textBox, @Nonnull FileChooserDescriptor descriptor, boolean showHidden, @Nullable consulo.disposer.Disposable parent) {
if(!(textBox instanceof TextBoxWithTextField)) {
throw new UnsupportedOperationException(textBox + " is not TextBoxWithTextField");
}
JTextField textField = ((TextBoxWithTextField)textBox).getTextField();
new FileTextFieldImpl.Vfs(textField, getMacroMap(), parent, new LocalFsFinder.FileChooserFilter(descriptor, showHidden));
}
public void setModel(final TestFrameworkRunningModel model) {
if (myModel != null) myModel.getTreeView().removeTreeSelectionListener(myTreeSelectionListener);
myModel = model;
if (model != null) {
myTreeSelectionListener = new MyTreeSelectionListener();
model.getTreeView().addTreeSelectionListener(myTreeSelectionListener);
Disposer.register(model, new Disposable() {
public void dispose() {
restoreMergedCoverage();
}
});
}
}
public void registerExecutor(final QueryExecutor<Result, Parameters> queryExecutor, Disposable parentDisposable) {
registerExecutor(queryExecutor);
Disposer.register(parentDisposable, new Disposable() {
@Override
public void dispose() {
unregisterExecutor(queryExecutor);
}
});
}
@Override
public void addPainter(final Component component, final Painter painter, final Disposable parent) {
getPainters().addPainter(painter, component);
activateIfNeeded();
Disposer.register(parent, new Disposable() {
@Override
public void dispose() {
SwingUtilities.invokeLater(() -> removePainter(painter));
}
});
}
public LazyUiDisposable(@Nullable Disposable parent, @Nonnull JComponent ui, @Nonnull T child) {
if (ApplicationProperties.isInSandbox()) {
myAllocation = new Exception();
}
myParent = parent;
myChild = child;
new UiNotifyConnector.Once(ui, this);
}
private static void registerDisposable(@Nonnull Disposable parentDisposable, @Nonnull VirtualFilePointerImpl pointer) {
DelegatingDisposable result = ourInstances.get(parentDisposable);
if (result == null) {
DelegatingDisposable newDisposable = new DelegatingDisposable(parentDisposable, pointer);
result = ConcurrencyUtil.cacheOrGet(ourInstances, parentDisposable, newDisposable);
if (result == newDisposable) {
Disposer.register(parentDisposable, result);
return;
}
}
result.increment(pointer);
}
public CoreProjectEnvironment(Disposable parentDisposable, CoreApplicationEnvironment applicationEnvironment) {
myParentDisposable = parentDisposable;
myEnvironment = applicationEnvironment;
myProject = new MockProject(myEnvironment.getApplication(), myParentDisposable);
preregisterServices();
myFileIndexFacade = createFileIndexFacade();
myMessageBus = (MessageBusImpl)myProject.getMessageBus();
PsiModificationTrackerImpl modificationTracker = new PsiModificationTrackerImpl(applicationEnvironment.getApplication(), myProject);
myProject.registerService(PsiModificationTracker.class, modificationTracker);
myProject.registerService(FileIndexFacade.class, myFileIndexFacade);
myProject.registerService(ResolveCache.class, new ResolveCache(myProject));
registerProjectExtensionPoint(PsiTreeChangePreprocessor.EP_NAME, PsiTreeChangePreprocessor.class);
myPsiManager = new PsiManagerImpl(myProject, () -> myFileIndexFacade, modificationTracker);
((FileManagerImpl)myPsiManager.getFileManager()).markInitialized();
registerProjectComponent(PsiManager.class, myPsiManager);
registerProjectComponent(PsiDocumentManager.class, new CorePsiDocumentManager(myProject, new MockDocumentCommitProcessor()));
myProject.registerService(ResolveScopeManager.class, createResolveScopeManager(myPsiManager));
myProject.registerService(PsiFileFactory.class, new PsiFileFactoryImpl(myPsiManager));
myProject.registerService(CachedValuesManager.class, new CachedValuesManagerImpl(myProject, new PsiCachedValuesFactory(myPsiManager)));
myProject.registerService(ProjectScopeBuilder.class, createProjectScopeBuilder());
myProject.registerService(DumbService.class, new MockDumbService(myProject));
}
@Nonnull
public static LinkLabel createRegExLink(@Nonnull String title, @Nullable final Component owner, @Nullable final Logger logger) {
return new LinkLabel(title, null, new LinkListener() {
JBPopup helpPopup;
@Override
public void linkSelected(LinkLabel aSource, Object aLinkData) {
try {
if (helpPopup != null && !helpPopup.isDisposed() && helpPopup.isVisible()) {
return;
}
helpPopup = createRegExHelpPopup();
Disposer.register(helpPopup, new Disposable() {
@Override
public void dispose() {
destroyPopup();
}
});
helpPopup.showInCenterOf(owner);
}
catch (BadLocationException e) {
if (logger != null) logger.info(e);
}
}
private void destroyPopup() {
helpPopup = null;
}
});
}