Example usage for com.intellij.openapi.wm ToolWindow getActivation

Introduction

In this page you can find the example usage for com.intellij.openapi.wm ToolWindow getActivation.

Prototype

@Deprecated
default ActionCallback getActivation() 

Source Link

Usage

From source file:com.intellij.psi.impl.file.PsiPackageImplementationHelperImpl.java

License:Apache License

@Override
public void navigate(final PsiJavaPackage psiPackage, final boolean requestFocus) {
    final Project project = psiPackage.getProject();
    ToolWindow window = ToolWindowManager.getInstance(project).getToolWindow(ToolWindowId.PROJECT_VIEW);
    window.activate(null);/* w w  w  .j a v a2s .c o m*/
    window.getActivation().doWhenDone(new Runnable() {
        @Override
        public void run() {
            final ProjectView projectView = ProjectView.getInstance(project);
            PsiDirectory[] directories = suggestMostAppropriateDirectories(psiPackage);
            if (directories.length == 0)
                return;
            projectView.select(directories[0], directories[0].getVirtualFile(), requestFocus);
        }
    });
}

---

From source file:org.cdv.intellij.ui.CDVToolWindowFactory.java

License:Open Source License

@Override
public void createToolWindowContent(@NotNull final Project project, @NotNull final ToolWindow toolWindow) {
    logger.info("CDVToolWindowFactory.createToolWindowContent");

    final CDVSwingContainer component = new CDVSwingContainer(new CDVJavaIDEAModuleNavigator(project),
            new CDVJavaIDEADependenciesFinder(project), new CDVJavIdeaModuleTypeProvider(project),
            new CDVJavaIDEAModuleChooser(project), new CDVJavaIDEANamespaceNavigator(project),
            new CDVIDEAFileSaveChooser(project), true, false);

    ContentFactory contentFactory = ContentFactory.SERVICE.getInstance();
    final Content content = contentFactory.createContent(component, "", false);
    toolWindow.getContentManager().addContent(content);

    final TimedQueueThread<VirtualFile> queue = new TimedQueueThread<>(
            new TimedQueueThread.ElementRunnable<VirtualFile>() {
                @Override//w ww  . j a v a2s  .  c  om
                public void run(final VirtualFile element) {
                    ApplicationManager.getApplication().runReadAction(new Runnable() {
                        @Override
                        public void run() {
                            refresh(project, component, element);
                        }
                    });
                }
            }, 1000);

    queue.start();

    toolWindow.getActivation().processOnDone(new Runnable() {
        @Override
        public void run() {
            logger.info("CDVToolWindowFactory.onDone");
            if (toolWindow.isVisible()) {
                refreshSelectedFile(project, component, queue);
            }
        }
    }, true);

    final DocumentListener documentListener = new DocumentListener() {
        @Override
        public void beforeDocumentChange(DocumentEvent documentEvent) {

        }

        @Override
        public void documentChanged(DocumentEvent documentEvent) {
            if (!isVisible(project, toolWindow)) {
                return;
            }
            final VirtualFile file = FileDocumentManager.getInstance().getFile(documentEvent.getDocument());
            PsiDocumentManager.getInstance(project).performForCommittedDocument(documentEvent.getDocument(),
                    new Runnable() {
                        @Override
                        public void run() {
                            queue.add(file);
                        }
                    });
        }
    };

    EditorFactory.getInstance().getEventMulticaster().addDocumentListener(documentListener);

    final FileEditorManagerListener fileEditorManagerListener = new FileEditorManagerListener() {
        @Override
        public void fileOpened(@NotNull FileEditorManager fileEditorManager, @NotNull VirtualFile virtualFile) {
            logger.info("CDVToolWindowFactory.fileOpened");
            if (isVisible(project, toolWindow)) {
                logger.info("CDVToolWindowFactory.fileOpened file=" + virtualFile);
                queue.add(virtualFile);
            }
        }

        @Override
        public void fileClosed(@NotNull FileEditorManager fileEditorManager, @NotNull VirtualFile virtualFile) {

        }

        @Override
        public void selectionChanged(@NotNull FileEditorManagerEvent fileEditorManagerEvent) {
            logger.info("CDVToolWindowFactory.selectionChanged");
            if (!isVisible(project, toolWindow)) {
                return;
            }
            final VirtualFile file = fileEditorManagerEvent.getNewFile();
            logger.info("CDVToolWindowFactory.selectionChanged file=" + file);
            if (file == null) {
                component.clear();
            } else {
                queue.add(file);
            }
        }
    };

    project.getMessageBus().connect().subscribe(FileEditorManagerListener.FILE_EDITOR_MANAGER,
            fileEditorManagerListener);

    final ToolWindowManagerListener toolWindowManagerListener = new ToolWindowManagerListener() {
        @Override
        public void toolWindowRegistered(@NotNull String s) {

        }

        @Override
        public void stateChanged() {
            if (isVisible(project, toolWindow)) {
                refreshSelectedFile(project, component, queue);
            }
        }
    };

    final ToolWindowManagerEx manager = ToolWindowManagerEx.getInstanceEx(project);

    manager.addToolWindowManagerListener(toolWindowManagerListener);

    ProjectManager.getInstance().addProjectManagerListener(new ProjectManagerListener() {
        @Override
        public void projectOpened(Project project) {

        }

        @Override
        public boolean canCloseProject(Project project) {
            return true;
        }

        @Override
        public void projectClosed(Project pr) {
            if (pr.equals(project)) {
                logger.info("CDVToolWindowFactory project closed");
                manager.removeToolWindowManagerListener(toolWindowManagerListener);
                EditorFactory.getInstance().getEventMulticaster().removeDocumentListener(documentListener);
                queue.stop();
                ProjectManager.getInstance().removeProjectManagerListener(this);
            }
        }

        @Override
        public void projectClosing(Project project) {

        }
    });
}

---