Example usage for com.intellij.openapi.fileEditor FileEditorManagerListener FileEditorManagerListener

List of usage examples for com.intellij.openapi.fileEditor FileEditorManagerListener FileEditorManagerListener

  1. HOME
  2. Java
  3. com.intellij.openapi
  4. com.intellij.openapi.fileEditor.*
  5. FileEditorManagerListener
  6. FileEditorManagerListener

Introduction

In this page you can find the example usage for com.intellij.openapi.fileEditor FileEditorManagerListener FileEditorManagerListener.

Prototype

FileEditorManagerListener

Source Link

Usage

From source file:com.chrisrm.idea.tabs.MTTabsPainterPatcherComponent.java

License:Open Source License

@Override
public void initComponent() {
    final MessageBus bus = ApplicationManagerEx.getApplicationEx().getMessageBus();

    final MessageBusConnection connect = bus.connect();
    connect.subscribe(FileEditorManagerListener.FILE_EDITOR_MANAGER, new FileEditorManagerListener() {
        @Override//from w  ww  . j av a  2 s. com
        public void selectionChanged(@NotNull final FileEditorManagerEvent event) {
            final FileEditor editor = event.getNewEditor();
            if (editor != null) {
                Component component = editor.getComponent();
                while (component != null) {
                    if (component instanceof JBEditorTabs) {
                        patchPainter((JBEditorTabs) component);
                        return;
                    }
                    component = component.getParent();
                }
            }
        }
    });

    // Listen to option save to set tab height
    setTabsHeight();
    connect.subscribe(ConfigNotifier.CONFIG_TOPIC, mtConfig -> setTabsHeight());

    try {
        hackTabsGetHeight();
        hackToolWindowHeader();
    } catch (final Exception e) {
        e.printStackTrace();
    }
}

From source file:com.denimgroup.threadfix.plugins.intellij.action.TestModuleComponent.java

License:Mozilla Public License

private FileEditorManagerListener getListener(final Project finalProject,
        final MessageBusConnection myConnection) {
    return new FileEditorManagerListener() {

        boolean hasBuiltTable = false;

        @Override/*  w w  w  .ja va 2 s  .c  om*/
        public void fileOpened(@Nonnull FileEditorManager source, @Nonnull VirtualFile file) {
            List<VulnerabilityMarker> markers = VulnerabilityMarkerService.getMarkersCache();

            if (!hasBuiltTable) {
                MarkerUtils.createMarkers(markers, finalProject);
                hasBuiltTable = true;
            }

            MarkerUtils.addMarkersToFile(finalProject, file, markers);
        }

        @Override
        public void fileClosed(@Nonnull FileEditorManager source, @Nonnull VirtualFile file) {
        }

        @Override
        public void selectionChanged(@Nonnull FileEditorManagerEvent event) {
        }
    };
}

From source file:io.flutter.coverage.FlutterLiveCoverageManager.java

License:Open Source License

private FlutterLiveCoverageManager(@NotNull Project project) {
    Disposer.register(project, this);

    FlutterAppManager.getInstance(project).getActiveAppAsStream().listen(this::updateCurrentAppChanged, true);

    final MessageBusConnection connection = project.getMessageBus().connect(project);

    final Editor editor = FileEditorManager.getInstance(project).getSelectedTextEditor();
    if (editor instanceof EditorEx) {
        lastFile = ((EditorEx) editor).getVirtualFile();

        if (couldContainCoverage(lastFile)) {
            lastEditor = FileEditorManager.getInstance(project).getSelectedEditor(lastFile);

            if (lastEditor == null) {
                lastFile = null;//  ww w  .  ja  v  a2  s  .co  m
            }
        }
    }

    connection.subscribe(FileEditorManagerListener.FILE_EDITOR_MANAGER, new FileEditorManagerListener() {
        public void selectionChanged(@NotNull FileEditorManagerEvent event) {
            if (couldContainCoverage(event.getNewFile())) {
                lastFile = event.getNewFile();
                lastEditor = editorFor(event);
            } else {
                lastFile = null;
                lastEditor = null;
            }

            notifyCoverage();
        }
    });
}

From source file:io.flutter.preview.PreviewView.java

License:Open Source License

public PreviewView(@NotNull Project project) {
    this.project = project;

    flutterAnalysisServer = FlutterDartAnalysisServer.getInstance(project);

    if (FlutterSettings.getInstance().isShowPreviewArea()) {
        myRenderHelper = new RenderHelper(project, renderListener);
    } else {/* w w  w  .ja v a  2 s  . c  o  m*/
        myRenderHelper = null;
    }

    // Show preview for the file selected when the view is being opened.
    final VirtualFile[] selectedFiles = FileEditorManager.getInstance(project).getSelectedFiles();
    if (selectedFiles.length != 0) {
        setSelectedFile(selectedFiles[0]);
    }

    final FileEditor[] selectedEditors = FileEditorManager.getInstance(project).getSelectedEditors();
    if (selectedEditors.length != 0) {
        setSelectedEditor(selectedEditors[0]);
    }

    // Listen for selecting files.
    final MessageBusConnection bus = project.getMessageBus().connect(project);
    bus.subscribe(FileEditorManagerListener.FILE_EDITOR_MANAGER, new FileEditorManagerListener() {
        @Override
        public void selectionChanged(@NotNull FileEditorManagerEvent event) {
            setSelectedFile(event.getNewFile());
            setSelectedEditor(event.getNewEditor());
        }
    });

    actionCenter = new QuickAssistAction("dart.assist.flutter.wrap.center", FlutterIcons.Center,
            "Center widget");
    actionPadding = new QuickAssistAction("dart.assist.flutter.wrap.padding", FlutterIcons.Padding,
            "Add padding");
    actionColumn = new QuickAssistAction("dart.assist.flutter.wrap.column", FlutterIcons.Column,
            "Wrap with Column");
    actionRow = new QuickAssistAction("dart.assist.flutter.wrap.row", FlutterIcons.Row, "Wrap with Row");
    actionMoveUp = new QuickAssistAction("dart.assist.flutter.move.up", FlutterIcons.Up, "Move widget up");
    actionMoveDown = new QuickAssistAction("dart.assist.flutter.move.down", FlutterIcons.Down,
            "Move widget down");
    actionRemove = new QuickAssistAction("dart.assist.flutter.removeWidget", FlutterIcons.RemoveWidget,
            "Remove widget");
    actionExtractMethod = new ExtractMethodAction();
}

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  . jav a 2s . c o m*/
                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) {

        }
    });
}

From source file:org.exbin.deltahex.intellij.DeltaHexFileEditor.java

License:Apache License

public DeltaHexFileEditor(Project project) {
    this.project = project;
    editorPanel = new JPanel();
    initComponents();//  w  ww  .  j av a2s  .  c o m

    preferences = getPreferences();

    codeArea = new CodeArea();
    codeArea.setPainter(new HighlightNonAsciiCodeAreaPainter(codeArea));
    codeArea.setFont(new Font(Font.MONOSPACED, Font.PLAIN, 12));
    codeArea.getCaret().setBlinkRate(300);
    statusPanel = new HexStatusPanel();
    registerEncodingStatus(statusPanel);
    encodingsHandler = new EncodingsHandler(new TextEncodingStatusApi() {
        @Override
        public String getEncoding() {
            return encodingStatus.getEncoding();
        }

        @Override
        public void setEncoding(String encodingName) {
            codeArea.setCharset(Charset.forName(encodingName));
            encodingStatus.setEncoding(encodingName);
            preferences.setValue(DeltaHexFileEditor.PREFERENCES_ENCODING_SELECTED, encodingName);
        }
    });

    propertyChangeSupport = new PropertyChangeSupport(this);
    // CodeAreaUndoHandler(codeArea);
    // undoHandler = new HexUndoIntelliJHandler(codeArea, project, this);
    undoHandler = new CodeAreaUndoHandler(codeArea);
    loadFromPreferences();

    undoHandler.addUndoUpdateListener(new BinaryDataUndoUpdateListener() {
        @Override
        public void undoCommandPositionChanged() {
            codeArea.repaint();
            updateUndoState();
            notifyModified();
        }

        @Override
        public void undoCommandAdded(final BinaryDataCommand command) {
            updateUndoState();
            notifyModified();
        }
    });
    updateUndoState();

    getSegmentsRepository();
    setNewData();
    CodeAreaOperationCommandHandler commandHandler = new CodeAreaOperationCommandHandler(codeArea, undoHandler);
    codeArea.setCommandHandler(commandHandler);
    editorPanel.add(codeArea, BorderLayout.CENTER);
    editorPanel.add(statusPanel, BorderLayout.SOUTH);
    registerHexStatus(statusPanel);
    goToHandler = new GoToHandler(codeArea);

    codeArea.addMouseListener(new MouseAdapter() {
        @Override
        public void mousePressed(MouseEvent e) {
            maybeShowPopup(e);
        }

        @Override
        public void mouseReleased(MouseEvent e) {
            maybeShowPopup(e);
        }

        private void maybeShowPopup(MouseEvent e) {
            if (e.isPopupTrigger()) {
                JPopupMenu popupMenu = createContextMenu();
                popupMenu.show(e.getComponent(), e.getX(), e.getY());
            }
        }
    });

    codeTypeComboBox.setSelectedIndex(codeArea.getCodeType().ordinal());

    editorPanel.getActionMap().put("copy-to-clipboard", new AbstractAction() {
        @Override
        public void actionPerformed(ActionEvent e) {
            codeArea.copy();
        }
    });
    editorPanel.getActionMap().put("cut-to-clipboard", new AbstractAction() {
        @Override
        public void actionPerformed(ActionEvent e) {
            codeArea.cut();
        }
    });
    editorPanel.getActionMap().put("paste-from-clipboard", new AbstractAction() {
        @Override
        public void actionPerformed(ActionEvent e) {
            codeArea.paste();
        }
    });

    applyFromCodeArea();

    int metaMaskValue;
    try {
        metaMaskValue = java.awt.Toolkit.getDefaultToolkit().getMenuShortcutKeyMask();
    } catch (java.awt.HeadlessException ex) {
        metaMaskValue = java.awt.Event.CTRL_MASK;
    }

    metaMask = metaMaskValue;

    codeArea.addKeyListener(new KeyAdapter() {
        @Override
        public void keyPressed(KeyEvent keyEvent) {
            int modifiers = keyEvent.getModifiers();
            if (modifiers == metaMask) {
                int keyCode = keyEvent.getKeyCode();
                switch (keyCode) {
                case KeyEvent.VK_F: {
                    showSearchPanel(false);
                    break;
                }
                case KeyEvent.VK_G: {
                    goToHandler.getGoToLineAction().actionPerformed(null);
                    break;
                }
                case KeyEvent.VK_S: {
                    saveFileButtonActionPerformed(null);
                    break;
                }
                }
            }

            if (modifiers == InputEvent.CTRL_MASK && keyEvent.getKeyCode() == KeyEvent.VK_Z) {
                try {
                    if (undoHandler.canUndo()) {
                        undoHandler.performUndo();
                    }
                } catch (BinaryDataOperationException e) {
                    e.printStackTrace();
                }
            } else if (modifiers == (InputEvent.CTRL_MASK | InputEvent.SHIFT_MASK)
                    && keyEvent.getKeyCode() == KeyEvent.VK_Z) {
                try {
                    if (undoHandler.canRedo()) {
                        undoHandler.performRedo();
                    }
                } catch (BinaryDataOperationException e) {
                    e.printStackTrace();
                }
            }
        }
    });

    MessageBus messageBus = project.getMessageBus();
    MessageBusConnection connect = messageBus.connect();
    connect.subscribe(FileEditorManagerListener.FILE_EDITOR_MANAGER, new FileEditorManagerListener() {
        @Override
        public void fileOpened(@NotNull FileEditorManager source, @NotNull VirtualFile file) {
        }

        @Override
        public void fileClosed(@NotNull FileEditorManager source, @NotNull VirtualFile file) {
            if (virtualFile != null) {
                if (!releaseFile()) {
                    // TODO Intercept close event instead of editor recreation
                    OpenFileDescriptor descriptor = new OpenFileDescriptor(project, virtualFile, 0);
                    FileEditorManager fileEditorManager = FileEditorManager.getInstance(project);
                    List<FileEditor> editors = fileEditorManager.openEditor(descriptor, true);
                    fileEditorManager.setSelectedEditor(virtualFile,
                            DeltaHexWindowProvider.DELTAHEX_EDITOR_TYPE_ID);
                    for (FileEditor fileEditor : editors) {
                        if (fileEditor instanceof DeltaHexFileEditor) {
                            ((DeltaHexFileEditor) fileEditor).reopenFile(virtualFile, codeArea.getData(),
                                    undoHandler);
                        }
                    }
                    closeData(false);
                } else {
                    closeData(true);
                }
            }

            virtualFile = null;
        }

        @Override
        public void selectionChanged(@NotNull FileEditorManagerEvent event) {
        }
    });
}

From source file:ru.artlebedev.idea.plugins.parser.indexer.ParserFileIndex.java

License:Apache License

public void projectOpened() {
    PsiTreeChangeListener myTreeChangeListener = new ParserTreeChangeListener();
    PsiManager.getInstance(myProject).addPsiTreeChangeListener(myTreeChangeListener);

    FileEditorManager.getInstance(myProject).addFileEditorManagerListener(new FileEditorManagerListener() {
        public void fileOpened(FileEditorManager source, VirtualFile file) {
            if (!hadFullReindex) {
                reindexProject();//from  w w  w  .ja  v a 2s . c  o m
                hadFullReindex = true;
            }
            if (file.getFileType() == ParserFileType.PARSER_FILE_TYPE) {
                contributeToClasses(file);
            }
        }

        public void fileClosed(FileEditorManager source, VirtualFile file) {
        }

        public void selectionChanged(FileEditorManagerEvent event) {
        }
    });

    VirtualFileAdapter myFileListener = new VirtualFileAdapter() {
        public void fileCreated(VirtualFileEvent event) {
            VirtualFile file = event.getFile();
            if (file.getFileType() == ParserFileType.PARSER_FILE_TYPE) {
                try {
                    PsiFile loadedFile = PsiManager.getInstance(myProject).findFile(file);
                    if (loadedFile != null) {
                        processFileAdded(loadedFile);
                    }
                } catch (Exception ignored) {

                }
            }
        }

        public void beforeFileDeleted(VirtualFileEvent event) {
            final VirtualFile fileOrDir = event.getFile();
            if (fileOrDir.getFileType() == ParserFileType.PARSER_FILE_TYPE) {
                processFileRemoved((ParserFile) PsiManager.getInstance(myProject).findFile(fileOrDir));
            }
        }
    };

    VirtualFileManager.getInstance().addVirtualFileListener(myFileListener);

    ProjectRootManager.getInstance(myProject).addModuleRootListener(new ModuleRootListener() {
        @Override
        public void beforeRootsChange(ModuleRootEvent event) {
            //To change body of implemented methods use File | Settings | File Templates.
        }

        @Override
        public void rootsChanged(ModuleRootEvent event) {
            reindexProject();
        }
    });

    initializeBaseClasses();
}