Examples with AbstractUrl com.intellij.ide.projectView.impl.AbstractUrl used on opensource projects

Example 1 with AbstractUrl

use of com.intellij.ide.projectView.impl.AbstractUrl in project intellij-community by JetBrains.

the class FavoritesListNode method processUrls.

private static void processUrls(Project project, Collection<TreeItem<Pair<AbstractUrl, String>>> urls, Collection<AbstractTreeNode> result, final AbstractTreeNode me) {
    for (TreeItem<Pair<AbstractUrl, String>> pair : urls) {
        AbstractUrl abstractUrl = pair.getData().getFirst();
        final Object[] path = abstractUrl.createPath(project);
        if (path == null || path.length < 1 || path[0] == null) {
            continue;
        }
        try {
            final String className = pair.getData().getSecond();
            @SuppressWarnings("unchecked") final Class<? extends AbstractTreeNode> nodeClass = (Class<? extends AbstractTreeNode>) Class.forName(className);
            final AbstractTreeNode node = ProjectViewNode.createTreeNode(nodeClass, project, path[path.length - 1], FavoritesManager.getInstance(project).getViewSettings());
            node.setParent(me);
            node.setIndex(result.size());
            result.add(node);
            if (node instanceof ProjectViewNodeWithChildrenList) {
                final List<TreeItem<Pair<AbstractUrl, String>>> children = pair.getChildren();
                if (children != null && !children.isEmpty()) {
                    Collection<AbstractTreeNode> childList = new ArrayList<>();
                    processUrls(project, children, childList, node);
                    for (AbstractTreeNode treeNode : childList) {
                        ((ProjectViewNodeWithChildrenList) node).addChild(treeNode);
                    }
                }
            }
        } catch (Exception e) {
            LOGGER.error(e);
        }
    }
}

Example 2 with AbstractUrl

use of com.intellij.ide.projectView.impl.AbstractUrl in project intellij-community by JetBrains.

the class PredefinedSearchScopeProviderImpl method getPredefinedScopes.

@NotNull
@Override
public List<SearchScope> getPredefinedScopes(@NotNull final Project project, @Nullable final DataContext dataContext, boolean suggestSearchInLibs, boolean prevSearchFiles, boolean currentSelection, boolean usageView, boolean showEmptyScopes) {
    Collection<SearchScope> result = ContainerUtil.newLinkedHashSet();
    result.add(GlobalSearchScope.everythingScope(project));
    result.add(GlobalSearchScope.projectScope(project));
    if (suggestSearchInLibs) {
        result.add(GlobalSearchScope.allScope(project));
    }
    if (ModuleUtil.isSupportedRootType(project, JavaSourceRootType.TEST_SOURCE)) {
        result.add(GlobalSearchScopesCore.projectProductionScope(project));
        result.add(GlobalSearchScopesCore.projectTestScope(project));
    }
    result.add(ScratchFileServiceImpl.buildScratchesSearchScope());
    final GlobalSearchScope openFilesScope = GlobalSearchScopes.openFilesScope(project);
    if (openFilesScope != GlobalSearchScope.EMPTY_SCOPE) {
        result.add(openFilesScope);
    } else if (showEmptyScopes) {
        result.add(new LocalSearchScope(PsiElement.EMPTY_ARRAY, IdeBundle.message("scope.open.files")));
    }
    final Editor selectedTextEditor = ApplicationManager.getApplication().isDispatchThread() ? FileEditorManager.getInstance(project).getSelectedTextEditor() : null;
    PsiFile psiFile = selectedTextEditor == null ? null : PsiDocumentManager.getInstance(project).getPsiFile(selectedTextEditor.getDocument());
    PsiFile currentFile = psiFile;
    if (dataContext != null) {
        PsiElement dataContextElement = CommonDataKeys.PSI_FILE.getData(dataContext);
        if (dataContextElement == null) {
            dataContextElement = CommonDataKeys.PSI_ELEMENT.getData(dataContext);
        }
        if (dataContextElement == null && psiFile != null) {
            dataContextElement = psiFile;
        }
        if (dataContextElement != null) {
            if (!PlatformUtils.isCidr()) {
                // TODO: have an API to disable module scopes.
                Module module = ModuleUtilCore.findModuleForPsiElement(dataContextElement);
                if (module == null) {
                    module = LangDataKeys.MODULE.getData(dataContext);
                }
                if (module != null && !(ModuleType.get(module) instanceof InternalModuleType)) {
                    result.add(module.getModuleScope());
                }
            }
            if (currentFile == null) {
                currentFile = dataContextElement.getContainingFile();
            }
        }
    }
    if (currentFile != null || showEmptyScopes) {
        PsiElement[] scope = currentFile != null ? new PsiElement[] { currentFile } : PsiElement.EMPTY_ARRAY;
        result.add(new LocalSearchScope(scope, IdeBundle.message("scope.current.file")));
    }
    if (currentSelection && selectedTextEditor != null && psiFile != null) {
        SelectionModel selectionModel = selectedTextEditor.getSelectionModel();
        if (selectionModel.hasSelection()) {
            int start = selectionModel.getSelectionStart();
            final PsiElement startElement = psiFile.findElementAt(start);
            if (startElement != null) {
                int end = selectionModel.getSelectionEnd();
                final PsiElement endElement = psiFile.findElementAt(end);
                if (endElement != null) {
                    final PsiElement parent = PsiTreeUtil.findCommonParent(startElement, endElement);
                    if (parent != null) {
                        final List<PsiElement> elements = new ArrayList<>();
                        final PsiElement[] children = parent.getChildren();
                        TextRange selection = new TextRange(start, end);
                        for (PsiElement child : children) {
                            if (!(child instanceof PsiWhiteSpace) && child.getContainingFile() != null && selection.contains(child.getTextOffset())) {
                                elements.add(child);
                            }
                        }
                        if (!elements.isEmpty()) {
                            SearchScope local = new LocalSearchScope(PsiUtilCore.toPsiElementArray(elements), IdeBundle.message("scope.selection"));
                            result.add(local);
                        }
                    }
                }
            }
        }
    }
    if (usageView) {
        addHierarchyScope(project, result);
        UsageView selectedUsageView = UsageViewManager.getInstance(project).getSelectedUsageView();
        if (selectedUsageView != null && !selectedUsageView.isSearchInProgress()) {
            final Set<Usage> usages = ContainerUtil.newTroveSet(selectedUsageView.getUsages());
            usages.removeAll(selectedUsageView.getExcludedUsages());
            if (prevSearchFiles) {
                final Set<VirtualFile> files = collectFiles(usages, true);
                if (!files.isEmpty()) {
                    GlobalSearchScope prev = new GlobalSearchScope(project) {

                        private Set<VirtualFile> myFiles;

                        @NotNull
                        @Override
                        public String getDisplayName() {
                            return IdeBundle.message("scope.files.in.previous.search.result");
                        }

                        @Override
                        public synchronized boolean contains(@NotNull VirtualFile file) {
                            if (myFiles == null) {
                                myFiles = collectFiles(usages, false);
                            }
                            return myFiles.contains(file);
                        }

                        @Override
                        public int compare(@NotNull VirtualFile file1, @NotNull VirtualFile file2) {
                            return 0;
                        }

                        @Override
                        public boolean isSearchInModuleContent(@NotNull Module aModule) {
                            return true;
                        }

                        @Override
                        public boolean isSearchInLibraries() {
                            return true;
                        }
                    };
                    result.add(prev);
                }
            } else {
                final List<PsiElement> results = new ArrayList<>(usages.size());
                for (Usage usage : usages) {
                    if (usage instanceof PsiElementUsage) {
                        final PsiElement element = ((PsiElementUsage) usage).getElement();
                        if (element != null && element.isValid() && element.getContainingFile() != null) {
                            results.add(element);
                        }
                    }
                }
                if (!results.isEmpty()) {
                    result.add(new LocalSearchScope(PsiUtilCore.toPsiElementArray(results), IdeBundle.message("scope.previous.search.results")));
                }
            }
        }
    }
    final FavoritesManager favoritesManager = FavoritesManager.getInstance(project);
    if (favoritesManager != null) {
        for (final String favorite : favoritesManager.getAvailableFavoritesListNames()) {
            final Collection<TreeItem<Pair<AbstractUrl, String>>> rootUrls = favoritesManager.getFavoritesListRootUrls(favorite);
            // ignore unused root
            if (rootUrls.isEmpty())
                continue;
            result.add(new GlobalSearchScope(project) {

                @NotNull
                @Override
                public String getDisplayName() {
                    return "Favorite \'" + favorite + "\'";
                }

                @Override
                public boolean contains(@NotNull final VirtualFile file) {
                    return ReadAction.compute(() -> favoritesManager.contains(favorite, file));
                }

                @Override
                public int compare(@NotNull final VirtualFile file1, @NotNull final VirtualFile file2) {
                    return 0;
                }

                @Override
                public boolean isSearchInModuleContent(@NotNull final Module aModule) {
                    return true;
                }

                @Override
                public boolean isSearchInLibraries() {
                    return true;
                }
            });
        }
    }
    ContainerUtil.addIfNotNull(result, getSelectedFilesScope(project, dataContext));
    return ContainerUtil.newArrayList(result);
}