com.intellij.usageView.UsageViewUtil Java Examples

private UsageViewPresentation createPresentation(PsiElement psiElement, FindUsagesOptions options,
        boolean toOpenInNewTab) {
    UsageViewPresentation presentation = new UsageViewPresentation();
    String scopeString = options.searchScope.getDisplayName();
    presentation.setScopeText(scopeString);
    String usagesString = options.generateUsagesString();
    presentation.setUsagesString(usagesString);
    String title = FindBundle.message("find.usages.of.element.in.scope.panel.title", usagesString,
            UsageViewUtil.getLongName(psiElement), scopeString);
    presentation.setTabText(title);
    presentation.setTabName(FindBundle
            .message("find.usages.of.element.tab.name", usagesString, UsageViewUtil.getShortName(psiElement)));
    presentation.setTargetsNodeText(StringUtil.capitalize(UsageViewUtil.getType(psiElement)));
    presentation.setOpenInNewTab(toOpenInNewTab);
    presentation.setShowCancelButton(true);
    return presentation;
}
 

public CSharpClassesViewDescriptor(PsiElement[] elementsToMove, PsiDirectory newParent)
{
	myElementsToMove = elementsToMove;
	if(elementsToMove.length == 1)
	{
		myProcessedElementsHeader = StringUtil.capitalize(RefactoringBundle.message("move.single.element.elements.header",
				UsageViewUtil.getType(elementsToMove[0]),
				newParent.getVirtualFile().getPresentableUrl()));
		myCodeReferencesText = RefactoringBundle.message("references.in.code.to.0.1",
				UsageViewUtil.getType(elementsToMove[0]), UsageViewUtil.getLongName(elementsToMove[0]));
	}
	else
	{
		if(elementsToMove[0] instanceof PsiFile)
		{
			myProcessedElementsHeader =
					StringUtil.capitalize(RefactoringBundle.message("move.files.elements.header", newParent.getVirtualFile().getPresentableUrl()));
		}
		else if(elementsToMove[0] instanceof PsiDirectory)
		{
			myProcessedElementsHeader = StringUtil
					.capitalize(RefactoringBundle.message("move.directories.elements.header", newParent.getVirtualFile().getPresentableUrl()));
		}
		myCodeReferencesText = RefactoringBundle.message("references.found.in.code");
	}
}
 

public MoveMultipleElementsViewDescriptor(PsiElement[] psiElements,
                                          String targetName) {
  myPsiElements = psiElements;
  if (psiElements.length == 1) {
    myProcessedElementsHeader = StringUtil.capitalize(
      RefactoringBundle.message("move.single.element.elements.header", UsageViewUtil.getType(psiElements[0]), targetName));
    myCodeReferencesText = RefactoringBundle
      .message("references.in.code.to.0.1", UsageViewUtil.getType(psiElements[0]), UsageViewUtil.getLongName(psiElements[0]));
  }
  else {
    if (psiElements.length > 0) {
      myProcessedElementsHeader = StringUtil.capitalize(
        RefactoringBundle
          .message("move.single.element.elements.header", StringUtil.pluralize(UsageViewUtil.getType(psiElements[0])), targetName));
    }
    myCodeReferencesText = RefactoringBundle.message("references.found.in.code");
  }
}
 

@NotNull
protected UsageInfo[] findUsages() {
  PsiReference[] refs = ReferencesSearch.search(myClass, GlobalSearchScope.projectScope(myProject), false).toArray(new PsiReference[0]);
  final ArrayList<UsageInfo> result = new ArrayList<UsageInfo>();
  detectTurnToSuperRefs(refs, result);
  final PsiPackage originalPackage = JavaDirectoryService.getInstance().getPackage(myClass.getContainingFile().getContainingDirectory());
  if (Comparing.equal(JavaDirectoryService.getInstance().getPackage(myTargetDirectory), originalPackage)) {
    result.clear();
  }
  for (final PsiReference ref : refs) {
    final PsiElement element = ref.getElement();
    if (!canTurnToSuper(element) && !RefactoringUtil.inImportStatement(ref, element)) {
      result.add(new BindToOldUsageInfo(element, ref, myClass));
    }
  }
  UsageInfo[] usageInfos = result.toArray(new UsageInfo[result.size()]);
  return UsageViewUtil.removeDuplicatedUsages(usageInfos);
}
 

public MoveFilesOrDirectoriesViewDescriptor(PsiElement[] elementsToMove, PsiDirectory newParent) {
  myElementsToMove = elementsToMove;
  if (elementsToMove.length == 1) {
    myProcessedElementsHeader = StringUtil.capitalize(RefactoringBundle.message("move.single.element.elements.header",
                                                                                UsageViewUtil.getType(elementsToMove[0]),
                                                                                newParent.getVirtualFile().getPresentableUrl()));
    myCodeReferencesText = RefactoringBundle.message("references.in.code.to.0.1",
                                                     UsageViewUtil.getType(elementsToMove[0]), UsageViewUtil.getLongName(elementsToMove[0]));
  }
  else {
    if (elementsToMove[0] instanceof PsiFile) {
      myProcessedElementsHeader =
        StringUtil.capitalize(RefactoringBundle.message("move.files.elements.header", newParent.getVirtualFile().getPresentableUrl()));
    }
    else if (elementsToMove[0] instanceof PsiDirectory){
      myProcessedElementsHeader = StringUtil
        .capitalize(RefactoringBundle.message("move.directories.elements.header", newParent.getVirtualFile().getPresentableUrl()));
    }
    myCodeReferencesText = RefactoringBundle.message("references.found.in.code");
  }
}
 

private void update(PsiElement element) {
  if (element != null && element.isValid()) {
    final ItemPresentation presentation = ((NavigationItem)element).getPresentation();
    myIcon = presentation == null ? null : presentation.getIcon();
    myPresentableText = presentation == null ? UsageViewUtil.createNodeText(element) : presentation.getPresentableText();
    if (myIcon == null) {
      if (element instanceof PsiMetaOwner) {
        final PsiMetaOwner psiMetaOwner = (PsiMetaOwner)element;
        final PsiMetaData metaData = psiMetaOwner.getMetaData();
        if (metaData instanceof PsiPresentableMetaData) {
          final PsiPresentableMetaData psiPresentableMetaData = (PsiPresentableMetaData)metaData;
          if (myIcon == null) myIcon = psiPresentableMetaData.getIcon();
        }
      }
      else if (element instanceof PsiFile) {
        final PsiFile psiFile = (PsiFile)element;
        final VirtualFile virtualFile = psiFile.getVirtualFile();
        if (virtualFile != null) {
          myIcon = VirtualFilePresentation.getIcon(virtualFile);
        }
      }
    }
  }
}
 

protected void customizeUsagesView(@Nonnull final UsageViewDescriptor viewDescriptor, @Nonnull final UsageView usageView) {
  Runnable refactoringRunnable = () -> {
    Set<UsageInfo> usagesToRefactor = UsageViewUtil.getNotExcludedUsageInfos(usageView);
    final UsageInfo[] infos = usagesToRefactor.toArray(UsageInfo.EMPTY_ARRAY);
    TransactionGuard.getInstance().submitTransactionAndWait(() -> {
      if (ensureElementsWritable(infos, viewDescriptor)) {
        execute(infos);
      }
    });
  };

  String canNotMakeString = RefactoringBundle.message("usageView.need.reRun");

  addDoRefactoringAction(usageView, refactoringRunnable, canNotMakeString);
  usageView.setRerunAction(new AbstractAction() {
    @Override
    public void actionPerformed(ActionEvent e) {
      doRun();
    }
  });
}
 

@Override
@Nonnull
protected UsageInfo[] findUsages() {
  List<UsageInfo> usages = Collections.synchronizedList(new ArrayList<UsageInfo>());
  for (PsiElement element : myElements) {
    boolean handled = false;
    for (SafeDeleteProcessorDelegate delegate : Extensions.getExtensions(SafeDeleteProcessorDelegate.EP_NAME)) {
      if (delegate.handlesElement(element)) {
        final NonCodeUsageSearchInfo filter = delegate.findUsages(element, myElements, usages);
        if (filter != null) {
          for (PsiElement nonCodeUsageElement : filter.getElementsToSearch()) {
            addNonCodeUsages(nonCodeUsageElement, usages, filter.getInsideDeletedCondition(), mySearchNonJava, mySearchInCommentsAndStrings);
          }
        }
        handled = true;
        break;
      }
    }
    if (!handled && element instanceof PsiNamedElement) {
      findGenericElementUsages(element, usages, myElements);
      addNonCodeUsages(element, usages, getDefaultInsideDeletedCondition(myElements), mySearchNonJava, mySearchInCommentsAndStrings);
    }
  }
  final UsageInfo[] result = usages.toArray(new UsageInfo[usages.size()]);
  return UsageViewUtil.removeDuplicatedUsages(result);
}
 

public String[] getSuggestedNames() {
  final LinkedHashSet<String> result = new LinkedHashSet<String>();
  final String initialName = VariableInplaceRenameHandler.getInitialName();
  if (initialName != null) {
    result.add(initialName);
  }
  result.add(UsageViewUtil.getShortName(myPsiElement));
  final NameSuggestionProvider[] providers = Extensions.getExtensions(NameSuggestionProvider.EP_NAME);
  for(NameSuggestionProvider provider: providers) {
    SuggestedNameInfo info = provider.getSuggestedNames(myPsiElement, myNameSuggestionContext, result);
    if (info != null) {
      mySuggestedNameInfo = info;
      if (provider instanceof PreferrableNameSuggestionProvider && !((PreferrableNameSuggestionProvider)provider).shouldCheckOthers()) break;
    }
  }
  return ArrayUtil.toStringArray(result);
}
 

protected void createNewNameComponent() {
  String[] suggestedNames = getSuggestedNames();
  myOldName = UsageViewUtil.getShortName(myPsiElement);
  myNameSuggestionsField = new NameSuggestionsField(suggestedNames, myProject, PlainTextFileType.INSTANCE, myEditor) {
    @Override
    protected boolean shouldSelectAll() {
      return myEditor == null || myEditor.getSettings().isPreselectRename();
    }
  };
  if (myPsiElement instanceof PsiFile && myEditor == null) {
    myNameSuggestionsField.selectNameWithoutExtension();
  }
  myNameChangedListener = new NameSuggestionsField.DataChanged() {
    @Override
    public void dataChanged() {
      processNewNameChanged();
    }
  };
  myNameSuggestionsField.addDataChangedListener(myNameChangedListener);

}
 

@Nonnull
@Override
public UsageInfo[] findUsages() {
  final List<UsageInfo> usages = new ArrayList<UsageInfo>();
  for (MoveDirectoryWithClassesHelper helper : MoveDirectoryWithClassesHelper.findAll()) {
    helper.findUsages(myFilesToMove.keySet(), myDirectories, usages, mySearchInComments, mySearchInNonJavaFiles, myProject);
  }
  return UsageViewUtil.removeDuplicatedUsages(usages.toArray(new UsageInfo[usages.size()]));
}
 

@Override
protected boolean isPreviewUsages(@Nonnull UsageInfo[] usages) {
  if (myForceShowPreview) return true;
  if (super.isPreviewUsages(usages)) return true;
  if (UsageViewUtil.reportNonRegularUsages(usages, myProject)) return true;
  return false;
}
 

@Override
protected void performRefactoringRename(final String newName,
                                        final StartMarkAction markAction) {
  try {
    final PsiNamedElement variable = getVariable();
    if (variable != null && !newName.equals(myOldName)) {
      if (isIdentifier(newName, variable.getLanguage())) {
        final PsiElement substituted = getSubstituted();
        if (substituted == null) {
          return;
        }

        final String commandName = RefactoringBundle
          .message("renaming.0.1.to.2", UsageViewUtil.getType(variable), DescriptiveNameUtil.getDescriptiveName(variable), newName);
        CommandProcessor.getInstance().executeCommand(myProject, new Runnable() {
          @Override
          public void run() {
            performRenameInner(substituted, newName);
            PsiDocumentManager.getInstance(myProject).commitAllDocuments();
          }
        }, commandName, null);
      }
    }
  }
  finally {
    try {
      ((DesktopEditorImpl)InjectedLanguageUtil.getTopLevelEditor(myEditor)).stopDumbLater();
    }
    finally {
      FinishMarkAction.finish(myProject, myEditor, markAction);
    }
  }
}
 

public static String calculatePsiElementDescriptionList(PsiElement[] elements) {
  StringBuilder buffer = new StringBuilder();
  for (int i = 0; i < elements.length; i++) {
    if (i > 0) buffer.append(", ");
    buffer.append(UsageViewUtil.getType(elements[i]));
    buffer.append(" ");
    buffer.append(DescriptiveNameUtil.getDescriptiveName(elements[i]));
  }

  return buffer.toString();
}
 

public RenameViewDescriptor(LinkedHashMap<PsiElement, String> renamesMap) {

    myElements = PsiUtilBase.toPsiElementArray(renamesMap.keySet());

    Set<String> processedElementsHeaders = new THashSet<String>();
    Set<String> codeReferences = new THashSet<String>();

    for (final PsiElement element : myElements) {
      LOG.assertTrue(element.isValid(), "Invalid element: " + element.toString());
      String newName = renamesMap.get(element);

      String prefix = "";
      if (element instanceof PsiDirectory/* || element instanceof PsiClass*/) {
        String fullName = UsageViewUtil.getLongName(element);
        int lastDot = fullName.lastIndexOf('.');
        if (lastDot >= 0) {
          prefix = fullName.substring(0, lastDot + 1);
        }
      }

      processedElementsHeaders.add(StringUtil.capitalize(
        RefactoringBundle.message("0.to.be.renamed.to.1.2", UsageViewUtil.getType(element), prefix, newName)));
      codeReferences.add(UsageViewUtil.getType(element) + " " + UsageViewUtil.getLongName(element));
    }


    myProcessedElementsHeader = StringUtil.join(ArrayUtil.toStringArray(processedElementsHeaders), ", ");
    myCodeReferencesText =  RefactoringBundle.message("references.in.code.to.0", StringUtil.join(ArrayUtil.toStringArray(codeReferences),
                                                                                                 ", "));
  }
 

@Nonnull
private static UsageViewPresentation createPresentation(@Nonnull PsiElement psiElement, @Nonnull FindUsagesOptions options, boolean toOpenInNewTab) {
  UsageViewPresentation presentation = new UsageViewPresentation();
  String scopeString = options.searchScope.getDisplayName();
  presentation.setScopeText(scopeString);
  String usagesString = generateUsagesString(options);
  presentation.setUsagesString(usagesString);
  String title = FindBundle.message("find.usages.of.element.in.scope.panel.title", usagesString, UsageViewUtil.getLongName(psiElement), scopeString);
  presentation.setTabText(title);
  presentation.setTabName(FindBundle.message("find.usages.of.element.tab.name", usagesString, UsageViewUtil.getShortName(psiElement)));
  presentation.setTargetsNodeText(StringUtil.capitalize(UsageViewUtil.getType(psiElement)));
  presentation.setOpenInNewTab(toOpenInNewTab);
  return presentation;
}
 

@Nonnull
@Override
public String getLongDescriptiveName() {
  SearchScope searchScope = myOptions.searchScope;
  String scopeString = searchScope.getDisplayName();
  PsiElement psiElement = getElement();

  return psiElement == null
         ? UsageViewBundle.message("node.invalid")
         : FindBundle.message("recent.find.usages.action.popup", StringUtil.capitalize(UsageViewUtil.getType(psiElement)), DescriptiveNameUtil.getDescriptiveName(psiElement), scopeString);
}
 

private void showUsages(final UsageInfo[] usages) {
  UsageViewPresentation presentation = new UsageViewPresentation();
  presentation.setTabText(RefactoringBundle.message("safe.delete.title"));
  presentation.setTargetsNodeText(RefactoringBundle.message("attempting.to.delete.targets.node.text"));
  presentation.setShowReadOnlyStatusAsRed(true);
  presentation.setShowCancelButton(true);
  presentation.setCodeUsagesString(RefactoringBundle.message("references.found.in.code"));
  presentation.setUsagesInGeneratedCodeString(RefactoringBundle.message("references.found.in.generated.code"));
  presentation.setNonCodeUsagesString(RefactoringBundle.message("occurrences.found.in.comments.strings.and.non.java.files"));
  presentation.setUsagesString(RefactoringBundle.message("usageView.usagesText"));

  UsageViewManager manager = UsageViewManager.getInstance(myProject);
  final UsageView usageView = showUsages(usages, presentation, manager);
  usageView.addPerformOperationAction(new RerunSafeDelete(myProject, myElements, usageView), RefactoringBundle.message("retry.command"), null,
                                      RefactoringBundle.message("rerun.safe.delete"));
  usageView.addPerformOperationAction(new Runnable() {
    @Override
    public void run() {
      UsageInfo[] preprocessedUsages = usages;
      for (SafeDeleteProcessorDelegate delegate : Extensions.getExtensions(SafeDeleteProcessorDelegate.EP_NAME)) {
        preprocessedUsages = delegate.preprocessUsages(myProject, preprocessedUsages);
        if (preprocessedUsages == null) return;
      }
      final UsageInfo[] filteredUsages = UsageViewUtil.removeDuplicatedUsages(preprocessedUsages);
      execute(filteredUsages);
    }
  }, "Delete Anyway", RefactoringBundle.message("usageView.need.reRun"), RefactoringBundle.message("usageView.doAction"));
}
 

@Override
protected boolean isPreviewUsages(@Nonnull UsageInfo[] usages) {
  if (myPreviewNonCodeUsages && UsageViewUtil.reportNonRegularUsages(usages, myProject)) {
    return true;
  }

  return super.isPreviewUsages(filterToBeDeleted(usages));
}
 

@Override
public String getElementDescription(@Nonnull final PsiElement element, @Nonnull final ElementDescriptionLocation location) {
  final String typeString = UsageViewUtil.getType(element);
  final String name = DescriptiveNameUtil.getDescriptiveName(element);
  return typeString + " " + CommonRefactoringUtil.htmlEmphasize(name);
}
 

@Override
protected JComponent createNorthPanel() {
  JPanel panel = new JPanel();

  panel.setLayout(new GridBagLayout());
  GridBagConstraints gbConstraints = new GridBagConstraints();

  gbConstraints.insets = new Insets(4, 0, 4, 8);
  gbConstraints.weighty = 1;
  gbConstraints.weightx = 1;
  gbConstraints.gridy = 0;
  gbConstraints.gridwidth = GridBagConstraints.REMAINDER;
  gbConstraints.fill = GridBagConstraints.BOTH;
  gbConstraints.anchor = GridBagConstraints.WEST;
  final JLabel classComboLabel = new JLabel();
  panel.add(classComboLabel, gbConstraints);

  myClassCombo = new JComboBox(mySuperClasses.toArray());
  initClassCombo(myClassCombo);
  classComboLabel.setText(RefactoringBundle.message("pull.up.members.to", UsageViewUtil.getLongName(myClass)));
  classComboLabel.setLabelFor(myClassCombo);
  final Class preselection = getPreselection();
  int indexToSelect = 0;
  if (preselection != null) {
    indexToSelect = mySuperClasses.indexOf(preselection);
  }
  myClassCombo.setSelectedIndex(indexToSelect);
  myClassCombo.addItemListener(new ItemListener() {
    @Override
    public void itemStateChanged(ItemEvent e) {
      if (e.getStateChange() == ItemEvent.SELECTED) {
        updateMemberInfo();
      }
    }
  });
  updateMemberInfo();
  gbConstraints.gridy++;
  panel.add(myClassCombo, gbConstraints);

  return panel;
}
 

private void setNewName(@Nonnull String newName) {
  myNewName = newName;
  myAllRenames.put(myPrimaryElement, newName);
  myCommandName = RefactoringBundle
          .message("renaming.0.1.to.2", UsageViewUtil.getType(myPrimaryElement), DescriptiveNameUtil.getDescriptiveName(myPrimaryElement), newName);
}
 

protected String getFullName() {
  final String name = DescriptiveNameUtil.getDescriptiveName(myPsiElement);
  return (UsageViewUtil.getType(myPsiElement) + " " + name).trim();
}
 

@Override
public void navigate(boolean requestFocus) {
  UsageViewUtil.navigateTo(getValue(), requestFocus);
}
 

private static String getNoUsagesFoundMessage(PsiElement psiElement) {
  String elementType = UsageViewUtil.getType(psiElement);
  String elementName = UsageViewUtil.getShortName(psiElement);
  return FindBundle.message("find.usages.of.element_type.element_name.not.found.message", elementType, elementName);
}
 

@Override
public void configureLabelComponent(@Nonnull SimpleColoredComponent coloredComponent) {
  coloredComponent.append(StringUtil.capitalize(UsageViewUtil.getType(myPsiElement)));
  coloredComponent.append(" ");
  coloredComponent.append(DescriptiveNameUtil.getDescriptiveName(myPsiElement), SimpleTextAttributes.REGULAR_BOLD_ATTRIBUTES);
}
 

public ChangeSignatureViewDescriptor(PsiElement method)
{
	myMethod = method;
	myProcessedElementsHeader = StringUtil.capitalize(RefactoringBundle.message("0.to.change.signature", UsageViewUtil.getType(method)));
}
 

private static String getFullName(@NotNull XmlTag tag) {
    String name = DescriptiveNameUtil.getDescriptiveName(tag.getAttribute("name"));
    return (UsageViewUtil.getType(tag) + " " + name).trim();
}