下面列出了怎么用com.intellij.psi.SmartPsiElementPointer的API类实例代码及写法,或者点击链接到github查看源代码。
@Override
public boolean isAvailable(@NotNull final Project project,
final Editor editor,
@NotNull final PsiElement psiElement) {
final boolean isDataSetFile;
if (editor instanceof EditorWindow) {
isDataSetFile = ((EditorWindow) editor).getDelegate()
.getDocument()
.getText()
.startsWith("<dataset>");
} else {
isDataSetFile = editor.getDocument().getText().startsWith("<dataset>");
}
SmartPsiElementPointer<SqlSelectStatement> pointer = getNearestPointer(project, psiElement);
final String selectedText = editor.getSelectionModel().getSelectedText();
final boolean hasSelectedQuery = editor.getSelectionModel().hasSelection() && selectedText.trim().toUpperCase().startsWith("SELECT");
return isDataSetFile && (hasSelectedQuery || pointer != null);
}
/**
* @return a PSI element associated with this lookup element. It's used for navigation, showing quick documentation and sorting by proximity to the current location.
* The default implementation tries to extract PSI element from {@link #getObject()} result.
*/
@Nullable
public PsiElement getPsiElement() {
Object o = getObject();
if (o instanceof PsiElement) {
return (PsiElement)o;
}
if (o instanceof ResolveResult) {
return ((ResolveResult)o).getElement();
}
if (o instanceof PsiElementNavigationItem) {
return ((PsiElementNavigationItem)o).getTargetElement();
}
if (o instanceof SmartPsiElementPointer) {
return ((SmartPsiElementPointer)o).getElement();
}
return null;
}
public PsiElement[] tryCreate(@Nonnull final String inputString) {
if (inputString.length() == 0) {
Messages.showMessageDialog(myProject, IdeBundle.message("error.name.should.be.specified"), CommonBundle.getErrorTitle(), Messages.getErrorIcon());
return PsiElement.EMPTY_ARRAY;
}
Ref<List<SmartPsiElementPointer>> createdElements = Ref.create();
Exception exception = executeCommand(getActionName(inputString), () -> {
PsiElement[] psiElements = create(inputString);
SmartPointerManager manager = SmartPointerManager.getInstance(myProject);
createdElements.set(ContainerUtil.map(psiElements, manager::createSmartPsiElementPointer));
});
if (exception != null) {
handleException(exception);
return PsiElement.EMPTY_ARRAY;
}
return ContainerUtil.mapNotNull(createdElements.get(), SmartPsiElementPointer::getElement).toArray(PsiElement.EMPTY_ARRAY);
}
/**
* Opens definition of method and highlights statements, which should be extracted.
*
* @param sourceMethod method from which code is proposed to be extracted into separate method.
* @param scope scope of the current project.
* @param slice computation slice.
*/
private static void openDefinition(@Nullable PsiMethod sourceMethod, AnalysisScope scope, ASTSlice slice) {
new Task.Backgroundable(scope.getProject(), "Search Definition") {
@Override
public void run(@NotNull ProgressIndicator indicator) {
indicator.setIndeterminate(true);
}
@Override
public void onSuccess() {
if (sourceMethod != null) {
Set<SmartPsiElementPointer<PsiElement>> statements = slice.getSliceStatements();
PsiStatement psiStatement = (PsiStatement) statements.iterator().next().getElement();
if (psiStatement != null && psiStatement.isValid()) {
EditorHelper.openInEditor(psiStatement);
Editor editor = FileEditorManager.getInstance(sourceMethod.getProject()).getSelectedTextEditor();
if (editor != null) {
TextAttributes attributes = EditorColorsManager.getInstance().getGlobalScheme().getAttributes(EditorColors.SEARCH_RESULT_ATTRIBUTES);
editor.getMarkupModel().removeAllHighlighters();
statements.stream()
.filter(statement -> statement.getElement() != null)
.forEach(statement ->
editor.getMarkupModel().addRangeHighlighter(statement.getElement().getTextRange().getStartOffset(),
statement.getElement().getTextRange().getEndOffset(), HighlighterLayer.SELECTION,
attributes, HighlighterTargetArea.EXACT_RANGE));
}
}
}
}
}.queue();
}
@Nullable
private static PsiElement getPsiElement(@SuppressWarnings("rawtypes") AbstractTreeNode node) {
Object value = node.getValue();
if (value instanceof PsiElement) {
return (PsiElement) value;
}
if (value instanceof SmartPsiElementPointer) {
return ((SmartPsiElementPointer) value).getElement();
}
return null;
}
private SmartPsiElementPointer<SqlSelectStatement> getNearestPointer(final @NotNull Project project,
final @NotNull PsiElement psiElement) {
SmartPsiElementPointer<SqlSelectStatement> pointer = getStatementPointer(project, psiElement);
if (pointer == null && psiElement.getPrevSibling() != null) {
pointer = getStatementPointer(project, psiElement.getPrevSibling());
}
if (pointer == null && psiElement.getPrevSibling() != null) {
final String prevText = psiElement.getPrevSibling().getText();
if ((prevText.equals(";") || prevText.isEmpty()) && psiElement.getPrevSibling().getPrevSibling() != null) {
pointer = getStatementPointer(project, psiElement.getPrevSibling().getPrevSibling());
}
}
return pointer;
}
@Nullable
private SmartPsiElementPointer<SqlSelectStatement> getStatementPointer(final @NotNull Project project,
final @NotNull PsiElement psiElement) {
final SqlSelectStatement sqlSelectStatement =
PsiTreeUtil.getParentOfType(psiElement.getContainingFile().findElementAt(psiElement.getTextOffset()),
SqlSelectStatement.class);
SmartPsiElementPointer<SqlSelectStatement> pointer = null;
if (sqlSelectStatement != null) {
pointer = SmartPointerManager.getInstance(project)
.createSmartPsiElementPointer(sqlSelectStatement);
}
return pointer;
}
@Nonnull
private static List<SmartPsiElementPointer<PsiElement>> convertToSmartPointers(@Nonnull PsiElement[] primaryElements) {
if (primaryElements.length == 0) return Collections.emptyList();
final SmartPointerManager smartPointerManager = SmartPointerManager.getInstance(primaryElements[0].getProject());
return ContainerUtil.mapNotNull(primaryElements, new Function<PsiElement, SmartPsiElementPointer<PsiElement>>() {
@Override
public SmartPsiElementPointer<PsiElement> fun(final PsiElement s) {
return smartPointerManager.createSmartPsiElementPointer(s);
}
});
}
@Nonnull
public List<SmartPsiElementPointer<PsiElement>> getAllElementPointers() {
List<SmartPsiElementPointer<PsiElement>> result = new ArrayList<SmartPsiElementPointer<PsiElement>>(myPrimarySearchedElements.size() + myAdditionalSearchedElements.size());
result.addAll(myPrimarySearchedElements);
result.addAll(myAdditionalSearchedElements);
return result;
}
@Nullable
private String getContainingFileName(RefElement ref) {
SmartPsiElementPointer pointer = ref.getPointer();
if (pointer == null) return null;
PsiFile file = pointer.getContainingFile();
if (file == null) return null;
return file.getName();
}
public void setData(@Nullable PsiElement element, @Nonnull String text, @Nullable String effectiveExternalUrl, @Nullable String ref, @Nullable DocumentationProvider provider) {
pushHistory();
myExternalUrl = effectiveExternalUrl;
myProvider = provider;
SmartPsiElementPointer<PsiElement> pointer = null;
if (element != null && element.isValid()) {
pointer = SmartPointerManager.getInstance(element.getProject()).createSmartPsiElementPointer(element);
}
setDataInternal(pointer, text, new Rectangle(0, 0), ref);
}
private void setDataInternal(@Nullable SmartPsiElementPointer<PsiElement> element, @Nonnull String text, @Nonnull Rectangle viewRect, @Nullable String ref) {
myIsEmpty = false;
if (myManager == null) return;
myText = text;
setElement(element);
myDecoratedText = decorate(text);
showHint(viewRect, ref);
}
@Nullable
@Override
protected Navigatable[] getNavigatables(DataContext dataContext) {
SmartPsiElementPointer<PsiElement> element = myElement;
if (element != null) {
PsiElement psiElement = element.getElement();
return psiElement instanceof Navigatable ? new Navigatable[]{(Navigatable)psiElement} : null;
}
return null;
}
Context(SmartPsiElementPointer<PsiElement> element, String text, String externalUrl, DocumentationProvider provider, Rectangle viewRect, int highlightedLink) {
this.element = element;
this.text = text;
this.externalUrl = externalUrl;
this.provider = provider;
this.viewRect = viewRect;
this.highlightedLink = highlightedLink;
}
public MyNavigationGutterIconRenderer(@Nonnull NavigationGutterIconBuilder builder,
final Alignment alignment,
final Image icon,
@Nullable final String tooltipText,
@Nonnull NotNullLazyValue<List<SmartPsiElementPointer>> pointers,
Computable<PsiElementListCellRenderer> cellRenderer,
boolean empty) {
super(builder.myPopupTitle, builder.myEmptyText, cellRenderer, pointers);
myAlignment = alignment;
myIcon = icon;
myTooltipText = tooltipText;
myEmpty = empty;
}
protected NavigationGutterIconRenderer(final String popupTitle, final String emptyText, @Nonnull Computable<PsiElementListCellRenderer> cellRenderer,
@Nonnull NotNullLazyValue<List<SmartPsiElementPointer>> pointers) {
myPopupTitle = popupTitle;
myEmptyText = emptyText;
myCellRenderer = cellRenderer;
myPointers = pointers;
}
public List<PsiElement> getTargetElements() {
return ContainerUtil.mapNotNull(myPointers.getValue(), new NullableFunction<SmartPsiElementPointer, PsiElement>() {
public PsiElement fun(final SmartPsiElementPointer smartPsiElementPointer) {
return smartPsiElementPointer.getElement();
}
});
}
@Nullable
public PsiElement getPsiElement(@Nonnull FoldRegion region) {
final SmartPsiElementPointer<?> pointer = myFoldRegionToSmartPointerMap.get(region);
if (pointer == null) {
return null;
}
PsiElement element = pointer.getElement();
return element != null && element.isValid() ? element : null;
}
public static String getLocation(final AbstractTreeNode element, final Project project) {
Object nodeElement = element.getValue();
if (nodeElement instanceof SmartPsiElementPointer) {
nodeElement = ((SmartPsiElementPointer)nodeElement).getElement();
}
if (nodeElement instanceof PsiElement) {
if (nodeElement instanceof PsiDirectory) {
return ((PsiDirectory)nodeElement).getVirtualFile().getPresentableUrl();
}
if (nodeElement instanceof PsiFile) {
final PsiFile containingFile = (PsiFile)nodeElement;
final VirtualFile virtualFile = containingFile.getVirtualFile();
return virtualFile != null ? virtualFile.getPresentableUrl() : "";
}
}
if (nodeElement instanceof LibraryGroupElement) {
return ((LibraryGroupElement)nodeElement).getModule().getName();
}
if (nodeElement instanceof NamedLibraryElement) {
final NamedLibraryElement namedLibraryElement = ((NamedLibraryElement)nodeElement);
final Module module = namedLibraryElement.getModule();
return (module != null ? module.getName() : "") + ":" + namedLibraryElement.getOrderEntry().getPresentableName();
}
final FavoriteNodeProvider[] nodeProviders = Extensions.getExtensions(FavoriteNodeProvider.EP_NAME, project);
for (FavoriteNodeProvider provider : nodeProviders) {
String location = provider.getElementLocation(nodeElement);
if (location != null) return location;
}
return null;
}
@Override
@Nullable
public Object retrieveElement(@Nonnull final Object pointer) {
if (pointer instanceof SmartPsiElementPointer) {
return ReadAction.compute(() -> ((SmartPsiElementPointer)pointer).getElement());
}
return super.retrieveElement(pointer);
}
@Override
public void freeAnchor(final Object element) {
if (element instanceof SmartPsiElementPointer) {
ApplicationManager.getApplication().runReadAction(() -> {
SmartPsiElementPointer pointer = (SmartPsiElementPointer)element;
Project project = pointer.getProject();
if (!project.isDisposed()) {
SmartPointerManager.getInstance(project).removePointer(pointer);
}
});
}
}
public StubTranslation(SmartPsiElementPointer<PsiElement> pointer, String id) {
this.psiElement = pointer;
this.id = id;
}
@Override
public void invoke(@NotNull final Project project,
final Editor editor,
@NotNull final PsiElement psiElement) throws IncorrectOperationException {
final ExtractorProperties extractorProperties =
ProjectSettings.getExtractorProperties(SimpleDataContext.getProjectContext(project));
final List<DbDataSource> dataSources = DbPsiFacade.getInstance(project).getDataSources();
if (dataSources.isEmpty()) {
showPopup(editor, MessageType.ERROR, "Could not find datasource.");
return;
}
final String selectedDataSourceName = extractorProperties.getSelectedDataSourceName();
final DbDataSource dataSource = getDataSource(editor, dataSources, selectedDataSourceName);
final String query;
if (editor.getSelectionModel().hasSelection()) {
query = StringUtil.trim(editor.getSelectionModel().getSelectedText());
} else {
final SmartPsiElementPointer<SqlSelectStatement> pointer = getNearestPointer(project, psiElement);
if (pointer != null) {
query = pointer.getElement().getText();
final int startOffset = pointer.getRange().getStartOffset();
int endOffset = pointer.getRange().getEndOffset();
if (editor.getDocument().getText(TextRange.create(endOffset, endOffset + 1)).equals(";")) {
endOffset += 1; // take semicolon after query
}
editor.getSelectionModel().setSelection(startOffset, endOffset);
} else {
query = null;
}
}
ApplicationManager.getApplication().executeOnPooledThread(new Runnable() {
@Override
public void run() {
applySelectionChange(project, editor, extractorProperties, dataSource, query);
}
});
}
protected SmartPsiElementPointer<PsiElement> createSmartPsiElementPointer(PsiElement psiElement) {
return this.spManager.createSmartPsiElementPointer(psiElement);
}
@Override
public PsiElement fun(final SmartPsiElementPointer<PsiElement> pointer) {
return pointer.getElement();
}
@Nonnull
private static PsiElement[] convertToPsiElements(@Nonnull List<SmartPsiElementPointer<PsiElement>> primary) {
return ContainerUtil.map2Array(primary, PsiElement.class, SMARTPOINTER_TO_ELEMENT_MAPPER);
}
@Override
public SmartPsiElementPointer getPointer() {
return myID;
}
@Nullable
public static PsiElement getFileContext(@Nonnull PsiFile file) {
SmartPsiElementPointer pointer = file.getUserData(INJECTED_IN_ELEMENT);
return pointer == null ? null : pointer.getElement();
}
private void setElement(SmartPsiElementPointer<PsiElement> element) {
myElement = element;
myModificationCount = getCurrentModificationCount();
}
private MyNavigationGutterIconRenderer createGutterIconRenderer(@Nonnull Project project) {
checkBuilt();
final SmartPointerManager manager = SmartPointerManager.getInstance(project);
NotNullLazyValue<List<SmartPsiElementPointer>> pointers = new NotNullLazyValue<List<SmartPsiElementPointer>>() {
@Override
@Nonnull
public List<SmartPsiElementPointer> compute() {
Set<PsiElement> elements = new THashSet<PsiElement>();
Collection<? extends T> targets = myTargets.getValue();
final List<SmartPsiElementPointer> list = new ArrayList<SmartPsiElementPointer>(targets.size());
for (final T target : targets) {
for (final PsiElement psiElement : myConverter.fun(target)) {
if (elements.add(psiElement) && psiElement.isValid()) {
list.add(manager.createSmartPsiElementPointer(psiElement));
}
}
}
return list;
}
};
final boolean empty = isEmpty();
if (myTooltipText == null && !myLazy) {
final SortedSet<String> names = new TreeSet<String>();
for (T t : myTargets.getValue()) {
final String text = myNamer.fun(t);
if (text != null) {
names.add(MessageFormat.format(PATTERN, text));
}
}
@NonNls StringBuilder sb = new StringBuilder("<html><body>");
if (myTooltipTitle != null) {
sb.append(myTooltipTitle).append("<br>");
}
for (String name : names) {
sb.append(name).append("<br>");
}
sb.append("</body></html>");
myTooltipText = sb.toString();
}
Computable<PsiElementListCellRenderer> renderer =
myCellRenderer == null ? new Computable<PsiElementListCellRenderer>() {
@Override
public PsiElementListCellRenderer compute() {
return new DefaultPsiElementCellRenderer();
}
} : myCellRenderer;
return new MyNavigationGutterIconRenderer(this, myAlignment, myIcon, myTooltipText, pointers, renderer, empty);
}