Example usage for com.intellij.openapi.fileTypes FileTypeManager TOPIC

Introduction

In this page you can find the example usage for com.intellij.openapi.fileTypes FileTypeManager TOPIC.

Prototype

Topic TOPIC

To view the source code for com.intellij.openapi.fileTypes FileTypeManager TOPIC.

Click Source Link

Usage

From source file:com.intellij.ide.todo.TodoView.java

License:Apache License

TodoView(Project project, ProjectLevelVcsManager manager) {
    myProject = project;// ww  w.  j a v a  2  s.com
    myVCSManager = manager;
    myCurrentPanelSettings = new TodoPanelSettings();
    myAllPanelSettings = new TodoPanelSettings();
    myChangeListTodosPanelSettings = new TodoPanelSettings();
    myPanels = new ArrayList<TodoPanel>();
    myNotAddedContent = new ArrayList<Content>();

    myVCSManager.addVcsListener(myVcsListener);

    final MyPropertyChangeListener myPropertyChangeListener = new MyPropertyChangeListener();
    TodoConfiguration.getInstance().addPropertyChangeListener(myPropertyChangeListener, this);

    MessageBusConnection connection = myProject.getMessageBus().connect(this);
    connection.subscribe(FileTypeManager.TOPIC, new MyFileTypeListener());
}

---

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

License:Apache License

public PsiVFSListener(Project project) {
    myProject = project;/*  w  w  w.ja  v  a2s . c om*/
    myFileTypeManager = FileTypeManager.getInstance();
    myProjectRootManager = ProjectRootManager.getInstance(project);
    myManager = (PsiManagerImpl) PsiManager.getInstance(project);
    myFileManager = (FileManagerImpl) myManager.getFileManager();

    myConnection = project.getMessageBus().connect(project);

    StartupManager.getInstance(project).registerPreStartupActivity(new Runnable() {
        @Override
        public void run() {
            final BulkVirtualFileListenerAdapter adapter = new BulkVirtualFileListenerAdapter(
                    PsiVFSListener.this);
            myConnection.subscribe(VirtualFileManager.VFS_CHANGES, new BulkFileListener() {
                @Override
                public void before(@NotNull List<? extends VFileEvent> events) {
                    adapter.before(events);
                }

                @Override
                public void after(@NotNull List<? extends VFileEvent> events) {
                    myReportedUnloadedPsiChange = false;
                    adapter.after(events);
                    myReportedUnloadedPsiChange = false;
                }
            });
            myConnection.subscribe(ProjectTopics.PROJECT_ROOTS, new MyModuleRootListener());
            myConnection.subscribe(FileTypeManager.TOPIC, new FileTypeListener.Adapter() {
                @Override
                public void fileTypesChanged(@NotNull FileTypeEvent e) {
                    myFileManager.processFileTypesChanged();
                }
            });
            myConnection.subscribe(AppTopics.FILE_DOCUMENT_SYNC, new MyFileDocumentManagerAdapter());
            myFileManager.markInitialized();
        }
    });
}

---

From source file:com.intellij.util.indexing.FileBasedIndexImpl.java

License:Apache License

public FileBasedIndexImpl(@SuppressWarnings("UnusedParameters") VirtualFileManager vfManager,
        FileDocumentManager fdm, FileTypeManagerImpl fileTypeManager, @NotNull MessageBus bus,
        SerializationManagerEx sm) {/*from w w  w. j  ava 2 s. co  m*/
    myFileDocumentManager = fdm;
    myFileTypeManager = fileTypeManager;
    mySerializationManagerEx = sm;
    myIsUnitTestMode = ApplicationManager.getApplication().isUnitTestMode();
    myConfigPath = calcConfigPath(PathManager.getConfigPath());
    myLogPath = calcConfigPath(PathManager.getLogPath());

    final MessageBusConnection connection = bus.connect();
    connection.subscribe(PsiDocumentTransactionListener.TOPIC, new PsiDocumentTransactionListener() {
        @Override
        public void transactionStarted(@NotNull final Document doc, @NotNull final PsiFile file) {
            myTransactionMap = myTransactionMap.plus(doc, file);
            myUpToDateIndicesForUnsavedOrTransactedDocuments.clear();
        }

        @Override
        public void transactionCompleted(@NotNull final Document doc, @NotNull final PsiFile file) {
            myTransactionMap = myTransactionMap.minus(doc);
        }
    });

    connection.subscribe(FileTypeManager.TOPIC, new FileTypeListener() {
        @Nullable
        private Map<FileType, Set<String>> myTypeToExtensionMap;

        @Override
        public void beforeFileTypesChanged(@NotNull final FileTypeEvent event) {
            cleanupProcessedFlag();
            myTypeToExtensionMap = new THashMap<FileType, Set<String>>();
            for (FileType type : myFileTypeManager.getRegisteredFileTypes()) {
                myTypeToExtensionMap.put(type, getExtensions(type));
            }
        }

        @Override
        public void fileTypesChanged(@NotNull final FileTypeEvent event) {
            final Map<FileType, Set<String>> oldExtensions = myTypeToExtensionMap;
            myTypeToExtensionMap = null;
            if (oldExtensions != null) {
                final Map<FileType, Set<String>> newExtensions = new THashMap<FileType, Set<String>>();
                for (FileType type : myFileTypeManager.getRegisteredFileTypes()) {
                    newExtensions.put(type, getExtensions(type));
                }
                // we are interested only in extension changes or removals.
                // addition of an extension is handled separately by RootsChanged event
                if (!newExtensions.keySet().containsAll(oldExtensions.keySet())) {
                    rebuildAllIndices();
                    return;
                }
                for (Map.Entry<FileType, Set<String>> entry : oldExtensions.entrySet()) {
                    FileType fileType = entry.getKey();
                    Set<String> strings = entry.getValue();
                    if (!newExtensions.get(fileType).containsAll(strings)) {
                        rebuildAllIndices();
                        return;
                    }
                }
            }
        }

        @NotNull
        private Set<String> getExtensions(@NotNull FileType type) {
            final Set<String> set = new THashSet<String>();
            for (FileNameMatcher matcher : myFileTypeManager.getAssociations(type)) {
                set.add(matcher.getPresentableString());
            }
            return set;
        }

        private void rebuildAllIndices() {
            IndexingStamp.flushCaches();
            for (ID<?, ?> indexId : myIndices.keySet()) {
                try {
                    clearIndex(indexId);
                } catch (StorageException e) {
                    LOG.info(e);
                }
            }
            scheduleIndexRebuild();
        }
    });

    connection.subscribe(AppTopics.FILE_DOCUMENT_SYNC, new FileDocumentManagerAdapter() {
        @Override
        public void fileContentReloaded(@NotNull VirtualFile file, @NotNull Document document) {
            cleanupMemoryStorage();
        }

        @Override
        public void unsavedDocumentsDropped() {
            cleanupMemoryStorage();
        }
    });

    ApplicationManager.getApplication().addApplicationListener(new ApplicationAdapter() {
        @Override
        public void writeActionStarted(Object action) {
            myUpToDateIndicesForUnsavedOrTransactedDocuments.clear();
        }
    });

    myChangedFilesCollector = new ChangedFilesCollector();
    myConnection = connection;
}

---