public boolean isImage(VirtualFile file) {
FileTypeManager fileTypeManager = FileTypeManager.getInstance();
- FileType fileTypeByFile = fileTypeManager.getFileTypeByFile(file);
+ FileType fileTypeByFile = file.getFileType();
return fileTypeByFile instanceof ImageFileType;
}
}
else if (files.length == 1) {
final VirtualFile file = files[0];
- FileType fileType = FileTypeManager.getInstance().getFileTypeByFile(file);
+ FileType fileType = file.getFileType();
if (CompilerManager.getInstance(project).isCompilableFileType(fileType) || isCompilableResourceFile(project, compilerConfiguration, file)) {
elementDescription = "'" + file.getName() + "'";
}
}
}
else {
- FileType fileType = typeManager.getFileTypeByFile(file);
+ FileType fileType = file.getFileType();
if (!(compilerManager.isCompilableFileType(fileType) || isCompilableResourceFile(project, compilerConfiguration, file))) {
continue;
}
}
else if (files.size() == 1) {
final VirtualFile file = files.iterator().next();
- FileType fileType = FileTypeManager.getInstance().getFileTypeByFile(file);
+ FileType fileType = file.getFileType();
if (CompilerManager.getInstance(project).isCompilableFileType(fileType)) {
elementDescription = "'" + file.getName() + "'";
}
}
}
else {
- FileType fileType = typeManager.getFileTypeByFile(file);
+ FileType fileType = file.getFileType();
if (!(compilerManager.isCompilableFileType(fileType))) {
continue;
}
if (fileOrDir.isDirectory()) return true;
if (!fileOrDir.isInLocalFileSystem()) return true;
if (myInSourceOnly && !myFileIndex.isInSourceContent(fileOrDir)) return true;
- if (myFileType == null || myFileType == fileTypeManager.getFileTypeByFile(fileOrDir)) {
+ if (myFileType == null || myFileType == fileOrDir.getFileType()) {
myFiles.add(fileOrDir);
}
return true;
addRecursively(files, file, fileType);
}
else {
- if (fileType == null || fileType.equals(typeManager.getFileTypeByFile(file))) {
+ if (fileType == null || fileType.equals(file.getFileType())) {
files.add(file);
}
}
addRecursively(container, child, fileType);
}
else {
- if (fileType == null || fileType.equals(typeManager.getFileTypeByFile(child))) {
+ if (fileType == null || fileType.equals(child.getFileType())) {
container.add(child);
}
}
public boolean processFile(final VirtualFile child) {
try {
assert child.isValid();
- if (!child.isDirectory() && myCompiler.getCompilableFileTypes().contains(typeManager.getFileTypeByFile(child))) {
+ if (!child.isDirectory() && myCompiler.getCompilableFileTypes().contains(child.getFileType())) {
updateOutputItemsList(outputDir, child, sourceRoot, packagePrefix, filesToRefresh, results, srcRootScope);
}
return true;
}
public boolean isCompilableFile(VirtualFile file, CompileContext context) {
- return !StdFileTypes.JAVA.equals(FILE_TYPE_MANAGER.getFileTypeByFile(file)) && myConfiguration.isResourceFile(file);
+ return !StdFileTypes.JAVA.equals(file.getFileType()) && myConfiguration.isResourceFile(file);
}
public void compile(final CompileContext context, Chunk<Module> moduleChunk, final VirtualFile[] files, OutputSink sink) {
}
final VirtualFile virtualFile = file.getVirtualFile();
- FileType fileType = virtualFile != null ? fileTypeManager.getFileTypeByFile(virtualFile) : null;
+ FileType fileType = virtualFile != null ? virtualFile.getFileType() : null;
if (DebuggerUtils.supportsJVMDebugging(fileType) || DebuggerUtils.supportsJVMDebugging(file)) {
DebuggerSession debuggerSession = DebuggerManagerEx.getInstanceEx(project).getContext().getDebuggerSession();
return debuggerSession != null && debuggerSession.isPaused();
FileTypeManager fileTypeManager = FileTypeManager.getInstance();
final VirtualFile virtualFile = file.getVirtualFile();
- FileType fileType = virtualFile != null ? fileTypeManager.getFileTypeByFile(virtualFile) : null;
+ FileType fileType = virtualFile != null ? virtualFile.getFileType() : null;
if (DebuggerUtils.supportsJVMDebugging(fileType) || DebuggerUtils.supportsJVMDebugging(file)) {
Breakpoint breakpoint = findBreakpoint(project);
if (breakpoint == null) {
if (file != null) {
FileTypeManager fileTypeManager = FileTypeManager.getInstance();
final VirtualFile virtualFile = file.getVirtualFile();
- FileType fileType = virtualFile != null ? fileTypeManager.getFileTypeByFile(virtualFile) : null;
+ FileType fileType = virtualFile != null ? virtualFile.getFileType() : null;
if (StdFileTypes.JAVA == fileType || StdFileTypes.CLASS == fileType) {
final PsiField field = FieldBreakpoint.findField(project, document, editor.getCaretModel().getOffset());
if(field != null){
if (file != null) {
FileTypeManager fileTypeManager = FileTypeManager.getInstance();
final VirtualFile virtualFile = file.getVirtualFile();
- FileType fileType = virtualFile != null ? fileTypeManager.getFileTypeByFile(virtualFile) : null;
+ FileType fileType = virtualFile != null ? virtualFile.getFileType() : null;
if (StdFileTypes.JAVA == fileType || StdFileTypes.CLASS == fileType) {
method = findMethod(project, editor);
}
return;
}
progress.setText(DebuggerBundle.message("progress.hotswap.scanning.path", filePath));
- if(file.getFileSystem() instanceof JarFileSystem && FileTypes.ARCHIVE.equals(fileTypeManager.getFileTypeByFile(file))) {
+ if(file.getFileSystem() instanceof JarFileSystem && FileTypes.ARCHIVE.equals(file.getFileType())) {
if(file.getTimeStamp() > timeStamp) {
super.acceptDirectory(file, fileRoot, filePath);
}
if (progress.isCancelled()) {
return;
}
- if (file.getTimeStamp() > timeStamp && StdFileTypes.CLASS.equals(fileTypeManager.getFileTypeByFile(file))) {
+ if (file.getTimeStamp() > timeStamp && StdFileTypes.CLASS.equals(file.getFileType())) {
//noinspection HardCodedStringLiteral
if (SystemInfo.isFileSystemCaseSensitive? filePath.endsWith(CLASS_EXTENSION) : StringUtil.endsWithIgnoreCase(filePath, CLASS_EXTENSION)) {
progress.setText(DebuggerBundle.message("progress.hotswap.scanning.path", filePath));
if (!isVisible || file.isDirectory()) {
return isVisible;
}
- return StdFileTypes.IDEA_MODULE.equals(FileTypeManager.getInstance().getFileTypeByFile(file));
+ return StdFileTypes.IDEA_MODULE.equals(file.getFileType());
}
}
}
\ No newline at end of file
}
protected Icon getIcon() {
- return FileTypeManager.getInstance().getFileTypeByFile(myFile).getIcon();
+ return myFile.getFileType().getIcon();
}
protected String getSecondaryText() {
}
private static Icon replaceIcon(VirtualFile file, int flags, Project project, Icon baseIcon) {
- FileType fileType = FileTypeManager.getInstance().getFileTypeByFile(file);
+ FileType fileType = file.getFileType();
if (fileType == StdFileTypes.JAVA && !FileIndexUtil.isJavaSourceFile(project, file)) {
return PlatformIcons.JAVA_OUTSIDE_SOURCE_ICON;
}
public static boolean isJavaSourceFile(@NotNull Project project, @NotNull VirtualFile file) {
FileTypeManager fileTypeManager = FileTypeManager.getInstance();
if (file.isDirectory()) return false;
- if (fileTypeManager.getFileTypeByFile(file) != StdFileTypes.JAVA) return false;
+ if (file.getFileType() != StdFileTypes.JAVA) return false;
if (fileTypeManager.isFileIgnored(file)) return false;
return ProjectRootManager.getInstance(project).getFileIndex().isInSource(file);
}
public boolean contains(VirtualFile file) {
if (!super.contains(file)) return false;
- final FileType fileType = FileTypeRegistry.getInstance().getFileTypeByFile(file);
+ final FileType fileType = file.getFileType();
for (FileType otherFileType : myFileTypes) {
if (fileType.equals(otherFileType)) return true;
}
* @author yole
*/
public class CoreFileTypeRegistry extends FileTypeRegistry {
- private Map<String, FileType> myExtensionsMap = new HashMap<String, FileType>();
- private List<FileType> myAllFileTypes = new ArrayList<FileType>();
+ private final Map<String, FileType> myExtensionsMap = new HashMap<String, FileType>();
+ private final List<FileType> myAllFileTypes = new ArrayList<FileType>();
public CoreFileTypeRegistry() {
myAllFileTypes.add(UnknownFileType.INSTANCE);
import com.intellij.lang.Language;
import com.intellij.openapi.fileEditor.impl.LoadTextUtil;
import com.intellij.openapi.fileTypes.FileType;
-import com.intellij.openapi.fileTypes.FileTypeRegistry;
import com.intellij.openapi.fileTypes.LanguageFileType;
import com.intellij.openapi.project.DefaultProjectFactory;
import com.intellij.openapi.project.Project;
myContentAsText = contentAsText;
myContent = content;
myCharset = charset;
- myFileType = FileTypeRegistry.getInstance().getFileTypeByFile(file);
+ myFileType = file.getFileType();
// remember name explicitly because the file could be renamed afterwards
myFileName = file.getName();
}
tempFile = LocalFileSystem.getInstance().findFileByPath(path);
}
if (tempFile != null && !tempFile.isDirectory()) {
- return Boolean.valueOf(FileTypeManager.getInstance().getFileTypeByFile(tempFile).equals(FileTypes.ARCHIVE));
+ return Boolean.valueOf(tempFile.getFileType().equals(FileTypes.ARCHIVE));
}
return Boolean.FALSE;
}
VirtualFile virtualFile = getVirtualFile(usage);
if (virtualFile != null) {
append(virtualFile.getName() + ": ", SimpleTextAttributes.REGULAR_ATTRIBUTES);
- setIcon(FileTypeManager.getInstance().getFileTypeByFile(virtualFile).getIcon());
+ setIcon(virtualFile.getFileType().getIcon());
PsiFile psiFile = PsiManager.getInstance(myProject).findFile(virtualFile);
if (psiFile != null) {
setIcon(psiFile.getIcon(0));
final Processor<UsageInfo> consumer) {
final VirtualFile virtualFile = psiFile.getVirtualFile();
if (virtualFile == null) return 0;
- if (FileTypeManager.getInstance().getFileTypeByFile(virtualFile).isBinary()) return 0; // do not decompile .class files
+ if (virtualFile.getFileType().isBinary()) return 0; // do not decompile .class files
final Document document = FileDocumentManager.getInstance().getDocument(virtualFile);
if (document == null) return 0;
final int[] offset = {0};
ApplicationManager.getApplication().runReadAction(new Runnable() {
public void run() {
if (!virtualFile.isValid()) return;
- if (FileTypeManager.getInstance().getFileTypeByFile(virtualFile).isBinary()) return;
+ if (virtualFile.getFileType().isBinary()) return;
length[0] = virtualFile.getLength();
}
});
final VirtualFileFilter contentFilter = new VirtualFileFilter() {
public boolean accept(final VirtualFile file) {
return file.isDirectory() ||
- !fileTypeManager.isFileIgnored(file) && !fileTypeManager.getFileTypeByFile(file).isBinary() && searchScope.contains(file);
+ !fileTypeManager.isFileIgnored(file) && !file.getFileType().isBinary() && searchScope.contains(file);
}
};
for (VirtualFile file : files) {
if (parent == null) break;
if (parent instanceof PsiFile) {
VirtualFile virtualFile = ((PsiFile)parent).getVirtualFile();
- if (virtualFile != null && myFileTypeManager.getFileTypeByFile(virtualFile) != FileTypes.PLAIN_TEXT) {
+ if (virtualFile != null && virtualFile.getFileType() != FileTypes.PLAIN_TEXT) {
// adding a class within a file causes a new node to appear in project view => entire dir should be updated
parent = ((PsiFile)parent).getContainingDirectory();
if (parent == null) break;
public boolean isContentJavaSourceFile(@NotNull VirtualFile file) {
return !file.isDirectory()
- && myFileTypeManager.getFileTypeByFile(file) == StdFileTypes.JAVA
+ && file.getFileType() == StdFileTypes.JAVA
&& !myFileTypeManager.isFileIgnored(file)
&& isInSourceContent(file);
}
public boolean isContentJavaSourceFile(@NotNull VirtualFile file) {
return !file.isDirectory() &&
- myFileTypeManager.getFileTypeByFile(file) == StdFileTypes.JAVA &&
+ file.getFileType() == StdFileTypes.JAVA &&
!myFileTypeManager.isFileIgnored(file) &&
isInSourceContent(file);
}
public boolean isLibraryClassFile(@NotNull VirtualFile file) {
if (file.isDirectory()) return false;
- if (myFileTypeManager.getFileTypeByFile(file) != StdFileTypes.CLASS) return false;
+ if (file.getFileType() != StdFileTypes.CLASS) return false;
if (myFileTypeManager.isFileIgnored(file)) return false;
VirtualFile parent = file.getParent();
DirectoryInfo parentInfo = getInfoForDirectory(parent);
return false; // do not index TODOs in library sources
}
- final FileType fileType = myFtManager.getFileTypeByFile(file);
+ final FileType fileType = file.getFileType();
if (ProjectUtil.isProjectOrWorkspaceFile(file, fileType)) {
return false;
}
package com.intellij.openapi.diff;
import com.intellij.openapi.fileTypes.FileType;
-import com.intellij.openapi.fileTypes.FileTypeManager;
import com.intellij.openapi.vfs.VirtualFile;
/**
public class DiffContentUtil {
public static FileType getContentType(VirtualFile file) {
if (file == null) return null;
- return FileTypeManager.getInstance().getFileTypeByFile(file);
+ return file.getFileType();
}
public static boolean isTextFile(VirtualFile file) {
return file != null && file.isValid() && !file.isDirectory() &&
- isTextType(FileTypeManager.getInstance().getFileTypeByFile(file));
+ isTextType(file.getFileType());
}
public static boolean isTextType(FileType fileType) {
public boolean isBinary() {
if (myFile.isDirectory()) return false;
- return FileTypeManager.getInstance().getFileTypeByFile(myFile).isBinary();
+ return myFile.getFileType().isBinary();
}
public static FileContent createFromTempFile(Project project, String name, String ext, byte[] content) throws IOException {
public static FragmentContent fromRangeMarker(RangeMarker rangeMarker, Project project) {
Document document = rangeMarker.getDocument();
VirtualFile file = FileDocumentManager.getInstance().getFile(document);
- FileType type = FileTypeManager.getInstance().getFileTypeByFile(file);
+ FileType type = file.getFileType();
return new FragmentContent(new DocumentContent(project, document), TextRange.create(rangeMarker), project, type);
}
final int lineStart = document.getLineStartOffset(line);
final int lineEnd = document.getLineEndOffset(line);
final CharSequence docText = document.getCharsSequence();
- final int tabSize = CodeStyleFacade.getInstance(project).getTabSize(FileTypeManager.getInstance().getFileTypeByFile(file));
+ final int tabSize = CodeStyleFacade.getInstance(project).getTabSize(file.getFileType());
offset = lineStart;
int col = 0;
if (file.isDirectory() && myChooseFolders) {
return file;
}
- boolean isJar = FileTypeManager.getInstance().getFileTypeByFile(file) == FileTypes.ARCHIVE;
+ boolean isJar = file.getFileType() == FileTypes.ARCHIVE;
if (!isJar) {
return acceptAsGeneralFile(file) ? file : null;
}
*/
package com.intellij.openapi.fileChooser;
-import com.intellij.openapi.fileTypes.FileTypeManager;
import com.intellij.openapi.fileTypes.FileTypes;
import com.intellij.openapi.vfs.JarFileSystem;
import com.intellij.openapi.vfs.VirtualFile;
public static boolean isArchive(VirtualFile file) {
if (isArchiveFileSystem(file) && file.getParent() == null) return true;
return !file.isDirectory() &&
- FileTypeManager.getInstance().getFileTypeByFile(file) == FileTypes.ARCHIVE &&
+ file.getFileType() == FileTypes.ARCHIVE &&
!isArchiveFileSystem(file.getParent());
}
if (vFile != null) {
// Attempt to navigate to the virtual file with unknown file type will show a modal dialog
// asking to register some file type for this file. This behaviour is undesirable when autoscrolling.
- if (FileTypeManager.getInstance().getFileTypeByFile(vFile) == FileTypes.UNKNOWN) return;
+ if (vFile.getFileType() == FileTypes.UNKNOWN) return;
}
Navigatable[] navigatables = PlatformDataKeys.NAVIGATABLE_ARRAY.getData(context);
if (navigatables != null) {
haveSmthToDo = false;
}
else {
- haveSmthToDo = FileTypeManager.getInstance().getFileTypeByFile(file) == FileTypes.UNKNOWN;
+ haveSmthToDo = file.getFileType() == FileTypes.UNKNOWN;
}
presentation.setVisible(haveSmthToDo || ActionPlaces.MAIN_MENU.equals(e.getPlace()));
presentation.setEnabled(haveSmthToDo);
import com.intellij.openapi.diff.DiffRequest;
import com.intellij.openapi.diff.impl.DiffUtil;
import com.intellij.openapi.fileTypes.FileType;
-import com.intellij.openapi.fileTypes.FileTypeManager;
import com.intellij.openapi.fileTypes.FileTypes;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.vfs.VirtualFile;
private boolean canExternalizeAsFile(VirtualFile file) {
if (file == null || file.isDirectory()) return false;
- FileType fileType = FileTypeManager.getInstance().getFileTypeByFile(file);
+ FileType fileType = file.getFileType();
if (fileType.isBinary() && fileType != FileTypes.UNKNOWN) return false;
return true;
}
public FileType getContentType() {
VirtualFile file = getFile();
if (file == null) return FileTypes.PLAIN_TEXT;
- return FileTypeManager.getInstance().getFileTypeByFile(file);
+ return file.getFileType();
}
private static void setDocumentText(final Document document, final String text, String name, Project project) {
}
VirtualFile vFile = FileDocumentManager.getInstance().getFile(document);
- final FileType fileType = vFile == null ? null : FileTypeManager.getInstance().getFileTypeByFile(vFile);
+ final FileType fileType = vFile == null ? null : vFile.getFileType();
int blockIndent = CodeStyleFacade.getInstance(project).getIndentSize(fileType);
doIndent(endIndex, startIndex, document, project, editor, blockIndent);
}
final Document doc = editor.getDocument();
VirtualFile vFile = FileDocumentManager.getInstance().getFile(doc);
- final FileType fileType = vFile == null ? null : FileTypeManager.getInstance().getFileTypeByFile(vFile);
+ final FileType fileType = vFile == null ? null : vFile.getFileType();
int tabSize = settings.getIndentSize(fileType);
int spacesToAddCount = tabSize - columnNumber % tabSize;
if (startIndex < 0 || endIndex < 0) return;
VirtualFile vFile = FileDocumentManager.getInstance().getFile(document);
- final FileType fileType = vFile == null ? null : FileTypeManager.getInstance().getFileTypeByFile(vFile);
+ final FileType fileType = vFile == null ? null : vFile.getFileType();
int blockIndent = CodeStyleFacade.getInstance(project).getIndentSize(fileType);
IndentSelectionAction.doIndent(endIndex, startIndex, document, project, editor, -blockIndent);
if (myAddedClasses.contains(file) || myTreeAccessAllowed) return false;
- FileType fileType = FileTypeManager.getInstance().getFileTypeByFile(file);
+ FileType fileType = file.getFileType();
return (fileType == StdFileTypes.JAVA || fileType == StdFileTypes.CLASS) && !file.getName().equals("package-info.java");
}
FileTypeManager fileTypeManager = FileTypeManager.getInstance();
VirtualFile[] children = dir.getChildren();
for (VirtualFile child : children) {
- if (!child.isDirectory() && (fileTypeManager == null || fileTypeManager.getFileTypeByFile(child) != FileTypes.UNKNOWN)) {
+ if (!child.isDirectory() && (fileTypeManager == null || child.getFileType() != FileTypes.UNKNOWN)) {
files.add(child);
}
else if (recursive && child.isDirectory()) {
private static boolean hasTextEditor(VirtualFile selectedFile) {
FileTypeManager fileTypeManager = FileTypeManager.getInstance();
- FileType fileType = fileTypeManager.getFileTypeByFile(selectedFile);
+ FileType fileType = selectedFile.getFileType();
return !fileType.isBinary() && fileType != StdFileTypes.GUI_DESIGNER_FORM;
}
});
Collections.reverse(myRevisions);
- myContentFileType = FileTypeManager.getInstance().getFileTypeByFile(file);
+ myContentFileType = file.getFileType();
final VcsConfiguration configuration = VcsConfiguration.getInstance(myProject);
public boolean isFileVisible(VirtualFile file, boolean showHiddenFiles) {
boolean b = super.isFileVisible(file, showHiddenFiles);
if (!file.isDirectory()) {
- b &= StdFileTypes.XML.equals(FileTypeManager.getInstance().getFileTypeByFile(file));
+ b &= StdFileTypes.XML.equals(file.getFileType());
}
return b;
}
}
if (ProjectUtil.isProjectOrWorkspaceFile(file)) return false;
- FileType type = FileTypeManager.getInstance().getFileTypeByFile(file);
+ FileType type = file.getFileType();
return types.get(type.getName()) != null;
}
public FileType getFileTypeByFile(VirtualFile file)
{
- FileType type = FileTypeManager.getInstance().getFileTypeByFile(file);
+ FileType type = file.getFileType();
return getFileTypeByType(type);
}
if (virtualFile == null) return false;
final ProjectOpenProcessor importProvider = ProjectOpenProcessor.getImportProvider(virtualFile);
if (importProvider != null && importProvider.isProjectFile(virtualFile)) return true;
- FileType fileType = FileTypeManager.getInstance().getFileTypeByFile(virtualFile);
+ FileType fileType = virtualFile.getFileType();
return
fileType == StdFileTypes.IDEA_PROJECT
|| fileType == StdFileTypes.IDEA_MODULE
private void showNextFileInfo() {
VirtualFile currentVirtualFile = getCurrentVirtualFile();
- FileType fileType = FileTypeManager.getInstance().getFileTypeByFile(currentVirtualFile);
+ FileType fileType = currentVirtualFile.getFileType();
myMessageLabel.setText(
com.intellij.CvsBundle.message("label.project.files.cannot.be.merged.without.conflict",
*/
public class GroovyProblemFileHighlightFilter implements Condition<VirtualFile> {
public boolean value(VirtualFile virtualFile) {
- return FileTypeManager.getInstance().getFileTypeByFile(virtualFile) == GroovyFileType.GROOVY_FILE_TYPE;
+ return virtualFile.getFileType() == GroovyFileType.GROOVY_FILE_TYPE;
}
}
final VirtualFile file = editor.getFile();
e.getPresentation().setVisible(
FileDocumentManager.getInstance().getDocument(file) != null &&
- FileTypeManager.getInstance().getFileTypeByFile(file) == StdFileTypes.GUI_DESIGNER_FORM
+ file.getFileType() == StdFileTypes.GUI_DESIGNER_FORM
);
}
//TODO[anton,vova] fire when changed
return
FileDocumentManager.getInstance().getDocument(myFile) != null &&
- FileTypeManager.getInstance().getFileTypeByFile(myFile) == StdFileTypes.GUI_DESIGNER_FORM;
+ myFile.getFileType() == StdFileTypes.GUI_DESIGNER_FORM;
}
public void selectNotify(){
public boolean accept(@NotNull final Project project, @NotNull final VirtualFile file){
return
- FileTypeManager.getInstance().getFileTypeByFile(file) == StdFileTypes.GUI_DESIGNER_FORM &&
+ file.getFileType() == StdFileTypes.GUI_DESIGNER_FORM &&
!StdFileTypes.GUI_DESIGNER_FORM.isBinary() &&
ModuleUtil.findModuleForFile(file, project) != null;
}
VirtualFile vFile = PlatformDataKeys.VIRTUAL_FILE.getData(context);
if (vFile != null) {
- final FileType fileType = FileTypeManager.getInstance().getFileTypeByFile(vFile);
+ final FileType fileType = vFile.getFileType();
if (fileType.equals(StdFileTypes.GUI_DESIGNER_FORM)) {
final PsiFile formFile = PsiManager.getInstance(project).findFile(vFile);
if (formFile == null) return null;
}
public boolean isFileVisible(VirtualFile file, boolean showHiddenFiles) {
- final FileType fileType = myFileTypeManager.getFileTypeByFile(file);
+ final FileType fileType = file.getFileType();
return file.isDirectory() || (super.isFileVisible(file, showHiddenFiles)
&& FileAssociationsManager.XML_FILES_LIST.contains(fileType));
}
FileTypeManager fileTypeManager = FileTypeManager.getInstance();
if (!fileTypeManager.isFileIgnored(file)
- && fileTypeManager.getFileTypeByFile(file) == StdFileTypes.JAVA) {
+ && file.getFileType() == StdFileTypes.JAVA) {
ourJavaFilesCount += increase;
return true;
//System.out.println("ourJavaFilesCount = " + ourJavaFilesCount);
}
PsiFile psiFile = e.getContainingFile();
- FileType fileType = FileTypeManager.getInstance().getFileTypeByFile(psiFile.getVirtualFile());
+ FileType fileType = psiFile.getVirtualFile().getFileType();
addAttributeSelection(result, e);
final FileViewProvider fileViewProvider = psiFile.getViewProvider();