Java RefactorJBundle.message方法代码示例

import com.intellij.refactoring.RefactorJBundle; //导入方法依赖的package包/类
private static void invoke(final PsiField field, Editor editor) {
  final Project project = field.getProject();
  final Set<PsiMethod> delegating = DelegationUtils.getDelegatingMethodsForField(field);
  if (delegating.isEmpty()) {
    final String message =
      RefactorJBundle.message("cannot.perform.the.refactoring") + RefactorJBundle.message("field.selected.is.not.used.as.a.delegate");
    CommonRefactoringUtil.showErrorHint(project, editor, message, null, getHelpID());
    return;
  }

  MemberInfo[] infos = new MemberInfo[delegating.size()];
  int i = 0;
  for (PsiMethod method : delegating) {
    final MemberInfo memberInfo = new MemberInfo(method);
    memberInfo.setChecked(true);
    memberInfo.setToAbstract(method.findDeepestSuperMethods().length == 0);
    infos[i++] = memberInfo;
  }
  new RemoveMiddlemanDialog(field, infos).show();
}
 

import com.intellij.refactoring.RefactorJBundle; //导入方法依赖的package包/类
private static String getCannotRefactorMessage(PsiClass containingClass) {
  if (containingClass == null) {
    return RefactorJBundle.message("the.caret.should.be.positioned.within.a.class.to.be.refactored");
  }
  if (containingClass.isInterface()) {
    return RefactorJBundle.message("the.selected.class.is.an.interface");
  }
  if (containingClass.isEnum()) {
    return RefactorJBundle.message("the.selected.class.is.an.enumeration");
  }
  if (containingClass.isAnnotationType()) {
    return RefactorJBundle.message("the.selected.class.is.an.annotation.type");
  }
  if (classIsInner(containingClass) && !containingClass.hasModifierProperty(PsiModifier.STATIC)) {
    return RefactorJBundle.message("the.refactoring.is.not.supported.on.non.static.inner.classes");
  }
  if (classIsTrivial(containingClass)) {
    return RefactorJBundle.message("the.selected.class.has.no.members.to.extract");
  }
  return null;
}
 

import com.intellij.refactoring.RefactorJBundle; //导入方法依赖的package包/类
public void invoke(@NotNull Project project, Editor editor, PsiFile file, DataContext dataContext) {
  final ScrollingModel scrollingModel = editor.getScrollingModel();
  scrollingModel.scrollToCaret(ScrollType.MAKE_VISIBLE);
  PsiMethod selectedMethod = getSelectedMethod(editor, file, dataContext);
  if (selectedMethod == null) {
    final String message = RefactorJBundle.message("cannot.perform.the.refactoring") +
                           RefactorJBundle.message("the.caret.should.be.positioned.at.the.name.of.the.method.to.be.refactored");
    CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.IntroduceParameterObject);
    return;
  }
  invoke(project, selectedMethod, editor);
}
 

import com.intellij.refactoring.RefactorJBundle; //导入方法依赖的package包/类
private static String getErrorMessage(PsiMethod newMethod) {
  final PsiParameter[] parameters = newMethod.getParameterList().getParameters();
  if (parameters.length == 0) {
   return RefactorJBundle.message("cannot.perform.the.refactoring") +
          RefactorJBundle.message("method.selected.has.no.parameters");
  }
  if (newMethod instanceof PsiCompiledElement) {
    return RefactorJBundle.message("cannot.perform.the.refactoring") +
           RefactorJBundle.message("the.selected.method.cannot.be.wrapped.because.it.is.defined.in.a.non.project.class");
  }
  return null;
}
 

import com.intellij.refactoring.RefactorJBundle; //导入方法依赖的package包/类
@Override
public String getConflictMessage() {
  if (!myGenerateAccessors && (!paramsNeedingSetters.isEmpty() || !paramsNeedingGetters.isEmpty())) {
    final StringBuffer buf = new StringBuffer();
    appendConflicts(buf, paramsNeedingGetters);
    appendConflicts(buf, paramsNeedingSetters);
    return RefactorJBundle.message("cannot.perform.the.refactoring") + buf.toString();
  }
  return null;
}
 

import com.intellij.refactoring.RefactorJBundle; //导入方法依赖的package包/类
public void invoke(@NotNull Project project, Editor editor, PsiFile file, DataContext dataContext) {
  final ScrollingModel scrollingModel = editor.getScrollingModel();
  scrollingModel.scrollToCaret(ScrollType.MAKE_VISIBLE);
  final PsiElement element = LangDataKeys.PSI_ELEMENT.getData(dataContext);
  PsiMethod selectedMethod = null;
  if (element instanceof PsiMethod) {
    selectedMethod = (PsiMethod)element;
  }
  else if (element instanceof PsiParameter && ((PsiParameter)element).getDeclarationScope() instanceof PsiMethod){
    selectedMethod = (PsiMethod)((PsiParameter)element).getDeclarationScope();
  }
  else {
    final CaretModel caretModel = editor.getCaretModel();
    final int position = caretModel.getOffset();
    final PsiElement elementAt = file.findElementAt(position);
    final PsiMethodCallExpression methodCallExpression =
     PsiTreeUtil.getParentOfType(elementAt, PsiMethodCallExpression.class);
    if (methodCallExpression != null) {
      selectedMethod = methodCallExpression.resolveMethod();
    } else {
      final PsiParameterList parameterList = PsiTreeUtil.getParentOfType(elementAt, PsiParameterList.class);
      if (parameterList != null && parameterList.getParent() instanceof PsiMethod) {
        selectedMethod = (PsiMethod)parameterList.getParent();
      }
    }
  }
  if (selectedMethod == null) {
    final String message = RefactorJBundle.message("cannot.perform.the.refactoring") +
                           RefactorJBundle.message("the.caret.should.be.positioned.at.the.name.of.the.method.to.be.refactored");
    CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.IntroduceParameterObject);
    return;
  }
  invoke(project, selectedMethod, editor);
}
 

import com.intellij.refactoring.RefactorJBundle; //导入方法依赖的package包/类
public void invoke(@NotNull Project project, Editor editor, PsiFile file, DataContext dataContext) {
  final ScrollingModel scrollingModel = editor.getScrollingModel();
  scrollingModel.scrollToCaret(ScrollType.MAKE_VISIBLE);
  final PsiElement element = dataContext.getData(LangDataKeys.PSI_ELEMENT);
  PsiMethod selectedMethod = null;
  if (element instanceof PsiMethod) {
    selectedMethod = (PsiMethod)element;
  }
  else if (element instanceof PsiParameter && ((PsiParameter)element).getDeclarationScope() instanceof PsiMethod){
    selectedMethod = (PsiMethod)((PsiParameter)element).getDeclarationScope();
  }
  else {
    final CaretModel caretModel = editor.getCaretModel();
    final int position = caretModel.getOffset();
    final PsiElement elementAt = file.findElementAt(position);
    final PsiMethodCallExpression methodCallExpression =
     PsiTreeUtil.getParentOfType(elementAt, PsiMethodCallExpression.class);
    if (methodCallExpression != null) {
      selectedMethod = methodCallExpression.resolveMethod();
    } else {
      final PsiParameterList parameterList = PsiTreeUtil.getParentOfType(elementAt, PsiParameterList.class);
      if (parameterList != null && parameterList.getParent() instanceof PsiMethod) {
        selectedMethod = (PsiMethod)parameterList.getParent();
      }
    }
  }
  if (selectedMethod == null) {
    final String message = RefactorJBundle.message("cannot.perform.the.refactoring") +
                           RefactorJBundle.message("the.caret.should.be.positioned.at.the.name.of.the.method.to.be.refactored");
    CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.IntroduceParameterObject);
    return;
  }
  invoke(project, selectedMethod, editor);
}
 

import com.intellij.refactoring.RefactorJBundle; //导入方法依赖的package包/类
protected String getCommandName() {
  final PsiClass containingClass = myMethod.getContainingClass();
  return RefactorJBundle.message("wrapped.return.command.name", myClassName, containingClass.getName(), '.', myMethod.getName());
}
 

import com.intellij.refactoring.RefactorJBundle; //导入方法依赖的package包/类
public String getProcessedElementsHeader(){
    return RefactorJBundle.message("method.whose.return.are.to.wrapped");
}
 

import com.intellij.refactoring.RefactorJBundle; //导入方法依赖的package包/类
public String getCodeReferencesText(int usagesCount, int filesCount){
    return RefactorJBundle.message("references.to.be.modified.usage.view",
            MyUsageViewUtil.getUsageCountInfo(usagesCount, filesCount, RefactorJBundle.message("reference")));
}
 

import com.intellij.refactoring.RefactorJBundle; //导入方法依赖的package包/类
public String getProcessedElementsHeader() {
    return RefactorJBundle.message("method.whose.parameters.are.to.wrapped");
}
 

import com.intellij.refactoring.RefactorJBundle; //导入方法依赖的package包/类
public String getCodeReferencesText(int usagesCount, int filesCount) {
    return RefactorJBundle.message("references.to.be.modified") + MyUsageViewUtil.getUsageCountInfo(usagesCount, filesCount, "reference");
}
 

import com.intellij.refactoring.RefactorJBundle; //导入方法依赖的package包/类
protected String getCommandName() {
  final PsiClass containingClass = method.getContainingClass();
  return RefactorJBundle.message("introduced.parameter.class.command.name", className, containingClass.getName(), method.getName());
}
 

import com.intellij.refactoring.RefactorJBundle; //导入方法依赖的package包/类
protected String getCommandName() {
  return RefactorJBundle.message("exposed.delegation.command.name", containingClass.getName(), '.', field.getName());
}
 

import com.intellij.refactoring.RefactorJBundle; //导入方法依赖的package包/类
public String getCodeReferencesText(int usagesCount, int filesCount) {
  return RefactorJBundle
    .message("references.to.expose.usage.view", MyUsageViewUtil.getUsageCountInfo(usagesCount, filesCount, "reference"));
}