public OperationStatus ensureFilesWritable(@NotNull VirtualFile... files) { if (files.length == 0) { return new OperationStatusImpl(VirtualFile.EMPTY_ARRAY); } ApplicationManager.getApplication().assertIsDispatchThread(); Set<VirtualFile> realFiles = new THashSet<VirtualFile>(files.length); for (VirtualFile file : files) { if (file instanceof VirtualFileWindow) file = ((VirtualFileWindow) file).getDelegate(); if (file != null) { realFiles.add(file); } } files = VfsUtil.toVirtualFileArray(realFiles); for (WritingAccessProvider accessProvider : myAccessProviders) { Collection<VirtualFile> denied = accessProvider.requestWriting(files); if (!denied.isEmpty()) { return new OperationStatusImpl(VfsUtil.toVirtualFileArray(denied)); } } final FileInfo[] fileInfos = createFileInfos(files); if (fileInfos.length == 0) { // if all files are already writable return createResultStatus(files); } if (ApplicationManager.getApplication().isUnitTestMode()) { return createResultStatus(files); } // This event count hack is necessary to allow actions that called this stuff could still get // data from their data contexts. // Otherwise data manager stuff will fire up an assertion saying that event count has been // changed (due to modal dialog show-up) // The hack itself is safe since we guarantee that focus will return to the same component had // it before modal dialog have been shown. final int savedEventCount = IdeEventQueue.getInstance().getEventCount(); if (myState.SHOW_DIALOG) { new ReadOnlyStatusDialog(myProject, fileInfos).show(); } else { processFiles( new ArrayList<FileInfo>(Arrays.asList(fileInfos)), null); // the collection passed is modified } IdeEventQueue.getInstance().setEventCount(savedEventCount); return createResultStatus(files); }
@Override public void recalculateOutputDirs() { final Module[] allModules = ModuleManager.getInstance(myProject).getModules(); final Set<VirtualFile> allDirs = new OrderedSet<VirtualFile>(); final Set<VirtualFile> testOutputDirs = new java.util.HashSet<VirtualFile>(); final Set<VirtualFile> productionOutputDirs = new java.util.HashSet<VirtualFile>(); CompilerPathsManager pathsManager = CompilerPathsManager.getInstance(getProject()); for (Module module : allModules) { final VirtualFile output = pathsManager.getCompilerOutput(module, ProductionContentFolderTypeProvider.getInstance()); if (output != null && output.isValid()) { allDirs.add(output); productionOutputDirs.add(output); } final VirtualFile testsOutput = pathsManager.getCompilerOutput(module, TestContentFolderTypeProvider.getInstance()); if (testsOutput != null && testsOutput.isValid()) { allDirs.add(testsOutput); testOutputDirs.add(testsOutput); } } myOutputDirectories = VfsUtil.toVirtualFileArray(allDirs); // need this to ensure that the sent contains only _dedicated_ test output dirs // Directories that are configured for both test and production classes must not be added in the // resulting set testOutputDirs.removeAll(productionOutputDirs); myTestOutputDirectories = Collections.unmodifiableSet(testOutputDirs); }
public boolean execute(boolean drop, boolean isInsideStartFinishGroup) { if (!myUndoableGroup.isUndoable()) { reportCannotUndo( CommonBundle.message("cannot.undo.error.contains.nonundoable.changes.message"), myUndoableGroup.getAffectedDocuments()); return false; } Set<DocumentReference> clashing = getStackHolder().collectClashingActions(myUndoableGroup); if (!clashing.isEmpty()) { reportCannotUndo( CommonBundle.message("cannot.undo.error.other.affected.files.changed.message"), clashing); return false; } if (!isInsideStartFinishGroup && myUndoableGroup.shouldAskConfirmation(isRedo())) { if (!askUser()) return false; } else { if (restore(getBeforeState())) { setBeforeState(new EditorAndState(myEditor, myEditor.getState(FileEditorStateLevel.UNDO))); return true; } } Collection<VirtualFile> readOnlyFiles = collectReadOnlyAffectedFiles(); if (!readOnlyFiles.isEmpty()) { final Project project = myManager.getProject(); final VirtualFile[] files = VfsUtil.toVirtualFileArray(readOnlyFiles); if (project == null) { return false; } final ReadonlyStatusHandler.OperationStatus operationStatus = ReadonlyStatusHandler.getInstance(project).ensureFilesWritable(files); if (operationStatus.hasReadonlyFiles()) { return false; } } Collection<Document> readOnlyDocuments = collectReadOnlyDocuments(); if (!readOnlyDocuments.isEmpty()) { for (Document document : readOnlyDocuments) { document.fireReadOnlyModificationAttempt(); } return false; } getStackHolder().removeFromStacks(myUndoableGroup); if (!drop) { getReverseStackHolder().addToStacks(myUndoableGroup); } performAction(); restore(getAfterState()); return true; }
private boolean checkReadonlyUsages() { final Set<VirtualFile> readOnlyUsages = getReadOnlyUsagesFiles(); return readOnlyUsages.isEmpty() || !ReadonlyStatusHandler.getInstance(myProject) .ensureFilesWritable(VfsUtil.toVirtualFileArray(readOnlyUsages)) .hasReadonlyFiles(); }
@NotNull private static VirtualFile[] filterByReadOnliness(@NotNull VirtualFile[] files) { List<VirtualFile> result = new ArrayList<VirtualFile>(); for (VirtualFile file : files) { if (file.isInLocalFileSystem()) { result.add(file); } } return VfsUtil.toVirtualFileArray(result); }
static VirtualFile[] getFiles(DataContext dataContext) { ArrayList<VirtualFile> filesList = new ArrayList<VirtualFile>(); VirtualFile[] files = CommonDataKeys.VIRTUAL_FILE_ARRAY.getData(dataContext); for (int i = 0; files != null && i < files.length; i++) { VirtualFile file = files[i]; if (file.isInLocalFileSystem()) { filesList.add(file); } } return VfsUtil.toVirtualFileArray(filesList); }
private VirtualFile[] getVirtualFileArray() { ArrayList<VirtualFile> result = new ArrayList<VirtualFile>(); TreePath[] selectionPaths = myTree.getSelectionPaths(); if (selectionPaths != null) { for (TreePath selectionPath : selectionPaths) { AbstractTreeNode treeNode = (AbstractTreeNode) selectionPath.getLastPathComponent(); result.addAll(treeNode.getVirtualFiles()); } } return VfsUtil.toVirtualFileArray(result); }
private static OperationStatus createResultStatus(final VirtualFile[] files) { List<VirtualFile> readOnlyFiles = new ArrayList<VirtualFile>(); for (VirtualFile file : files) { if (file.exists()) { if (!file.isWritable()) { readOnlyFiles.add(file); } } } return new OperationStatusImpl(VfsUtil.toVirtualFileArray(readOnlyFiles)); }
@NotNull public VirtualFile[] getOpenFiles() { final ArrayListSet<VirtualFile> files = new ArrayListSet<VirtualFile>(); for (final EditorWindow myWindow : myWindows) { final EditorWithProviderComposite[] editors = myWindow.getEditors(); for (final EditorWithProviderComposite editor : editors) { final VirtualFile file = editor.getFile(); LOG.assertTrue(file.isValid(), Arrays.toString(editor.getProviders())); files.add(file); } } return VfsUtil.toVirtualFileArray(files); }
@Override protected VirtualFile[] computeFiles(PsiFile context, boolean compileTimeOnly) { final ArrayList<VirtualFile> files = new ArrayList<VirtualFile>(); processIncludingFiles( context, new Processor<Pair<VirtualFile, FileIncludeInfo>>() { @Override public boolean process( Pair<VirtualFile, FileIncludeInfo> virtualFileFileIncludeInfoPair) { files.add(virtualFileFileIncludeInfoPair.first); return true; } }); return VfsUtil.toVirtualFileArray(files); }
@NotNull public VirtualFile[] getOpenFiles() { final ArrayListSet<VirtualFile> files = new ArrayListSet<VirtualFile>(); for (final EditorWindow myWindow : myWindows) { final EditorWithProviderComposite[] editors = myWindow.getEditors(); for (final EditorWithProviderComposite editor : editors) { VirtualFile file = editor.getFile(); // background thread may call this method when invalid file is being removed // do not return it here as it will quietly drop out soon if (file.isValid()) { files.add(file); } } } return VfsUtil.toVirtualFileArray(files); }
private VirtualFile[] doAdd() { VirtualFile baseDir = myAddBaseDir; Project project = PlatformDataKeys.PROJECT.getData(DataManager.getInstance().getDataContext(myPanel)); if (baseDir == null && project != null) { baseDir = project.getBaseDir(); } VirtualFile[] files = FileChooser.chooseFiles(myDescriptor, myPanel, project, baseDir); files = adjustAddedFileSet(myPanel, files); List<VirtualFile> added = new ArrayList<VirtualFile>(files.length); for (VirtualFile vFile : files) { if (addElement(vFile)) { added.add(vFile); } } return VfsUtil.toVirtualFileArray(added); }
@Override protected VirtualFile[] computeFiles(final PsiFile file, final boolean compileTimeOnly) { final ArrayList<VirtualFile> files = new ArrayList<VirtualFile>(); processIncludes( file, new Processor<FileIncludeInfo>() { @Override public boolean process(FileIncludeInfo info) { if (compileTimeOnly != info.runtimeOnly) { PsiFileSystemItem item = resolveFileInclude(info, file); if (item != null) { ContainerUtil.addIfNotNull(files, item.getVirtualFile()); } } return true; } }); return VfsUtil.toVirtualFileArray(files); }
private static VirtualFile[] getFilesToCheckReadonlyStatus( GeneratingCompiler.GenerationItem[] items) { List<VirtualFile> filesToCheck = new ArrayList<VirtualFile>(); for (GeneratingCompiler.GenerationItem item : items) { if (item instanceof AndroidAptCompiler.AptGenerationItem) { final Set<File> generatedFiles = ((AndroidAptCompiler.AptGenerationItem) item).getGeneratedFiles().keySet(); for (File generatedFile : generatedFiles) { if (generatedFile.exists()) { VirtualFile generatedVFile = LocalFileSystem.getInstance().findFileByIoFile(generatedFile); if (generatedVFile != null) { filesToCheck.add(generatedVFile); } } } } } return VfsUtil.toVirtualFileArray(filesToCheck); }
@Override public VirtualFile[] getFiles(OrderRootType rootType) { List<VirtualFile> result = new ArrayList<VirtualFile>(); for (LightFilePointer pointer : myRoots.get(rootType)) { final VirtualFile file = pointer.getFile(); if (file == null) { continue; } if (file.isDirectory()) { final String url = file.getUrl(); if (myJarDirectories.contains(rootType, url)) { LibraryImpl.collectJarFiles(file, result, myJarDirectories.isRecursive(rootType, url)); continue; } } result.add(file); } return VfsUtil.toVirtualFileArray(result); }
@NotNull public VirtualFile[] getSelectedFiles() { final ArrayListSet<VirtualFile> files = new ArrayListSet<VirtualFile>(); for (final EditorWindow window : myWindows) { final VirtualFile file = window.getSelectedFile(); if (file != null) { files.add(file); } } final VirtualFile[] virtualFiles = VfsUtil.toVirtualFileArray(files); final VirtualFile currentFile = getCurrentFile(); if (currentFile != null) { for (int i = 0; i != virtualFiles.length; ++i) { if (Comparing.equal(virtualFiles[i], currentFile)) { virtualFiles[i] = virtualFiles[0]; virtualFiles[0] = currentFile; break; } } } return virtualFiles; }
@Override public VirtualFile[] occursInPackagePrefixes(PsiPackage psiPackage) { List<VirtualFile> result = new ArrayList<VirtualFile>(); final Module[] modules = ModuleManager.getInstance(psiPackage.getProject()).getModules(); for (final Module module : modules) { for (final ContentEntry contentEntry : ModuleRootManager.getInstance(module).getContentEntries()) { final List<SourceFolder> sourceFolders = contentEntry.getSourceFolders(JavaModuleSourceRootTypes.SOURCES); for (final SourceFolder sourceFolder : sourceFolders) { final String packagePrefix = sourceFolder.getPackagePrefix(); if (packagePrefix.startsWith(psiPackage.getQualifiedName())) { final VirtualFile file = sourceFolder.getFile(); if (file != null) { result.add(file); } } } } } return VfsUtil.toVirtualFileArray(result); }
public VirtualFile[] getAllFiles(VirtualFile file, boolean compileTimeOnly) { Set<VirtualFile> result = new HashSet<VirtualFile>(); getFilesRecursively(file, compileTimeOnly, result); return VfsUtil.toVirtualFileArray(result); }