import com.intellij.refactoring.PackageWrapper; //导入依赖的package包/类
protected void doAction() {
  final boolean useExistingClass = useExistingClassButton.isSelected();
  final boolean createInnerClass = myCreateInnerClassButton.isSelected();
  final String existingClassName = existingClassField.getText().trim();
  final String className;
  final String packageName;
  if (useExistingClass) {
    className = StringUtil.getShortName(existingClassName);
    packageName = StringUtil.getPackageName(existingClassName);
  }
  else if (createInnerClass) {
    className = getInnerClassName();
    packageName = "";
  }
  else {
    className = getClassName();
    packageName = getPackageName();
  }
  invokeRefactoring(
    new WrapReturnValueProcessor(className, packageName, ((DestinationFolderComboBox)myDestinationCb).selectDirectory(new PackageWrapper(sourceMethod.getManager(), packageName), false),
                                 sourceMethod, useExistingClass, createInnerClass, (PsiField)myFieldsCombo.getSelectedItem()));
}
 

import com.intellij.refactoring.PackageWrapper; //导入依赖的package包/类
protected void doAction() {
  TableUtil.stopEditing(myTable);

  final String className;
  final String packageName;
  if (myCreateBuilderClassRadioButton.isSelected()) {
    className = myNewClassName.getText().trim();
    packageName = myPackageTextField.getText().trim();
  } else {
    final String fqName = myExistentClassTF.getText().trim();
    className = StringUtil.getShortName(fqName);
    packageName = StringUtil.getPackageName(fqName);
    final PsiClass builderClass = JavaPsiFacade.getInstance(myProject).findClass(StringUtil.getQualifiedName(packageName, className), GlobalSearchScope.projectScope(myProject));
    if (builderClass != null && !CommonRefactoringUtil.checkReadOnlyStatus(myProject, builderClass)) return;
  }
  invokeRefactoring(new ReplaceConstructorWithBuilderProcessor(getProject(), myConstructors, myParametersMap, className, packageName,
                                                               ((DestinationFolderComboBox)myDestinationCb).selectDirectory(new PackageWrapper(myConstructors[0].getManager(), packageName), false),
                                                               myCreateBuilderClassRadioButton.isSelected()));
}
 

import com.intellij.refactoring.PackageWrapper; //导入依赖的package包/类
@Nullable
public MoveDestination selectDirectory(final PackageWrapper targetPackage, final boolean showChooserWhenDefault) {
  final DirectoryChooser.ItemWrapper selectedItem = (DirectoryChooser.ItemWrapper)getComboBox().getSelectedItem();
  if (selectedItem == null || selectedItem == NULL_WRAPPER) {
    return new MultipleRootsMoveDestination(targetPackage);
  }
  final PsiDirectory selectedPsiDirectory = selectedItem.getDirectory();
  VirtualFile selectedDestination = selectedPsiDirectory.getVirtualFile();
  if (showChooserWhenDefault &&
      myInitialTargetDirectory != null && Comparing.equal(selectedDestination, myInitialTargetDirectory.getVirtualFile()) &&
      mySourceRoots.size() > 1) {
    selectedDestination = MoveClassesOrPackagesUtil.chooseSourceRoot(targetPackage, mySourceRoots, myInitialTargetDirectory);
  }
  if (selectedDestination == null) return null;
  return new AutocreatingSingleSourceRootMoveDestination(targetPackage, selectedDestination);
}
 

import com.intellij.refactoring.PackageWrapper; //导入依赖的package包/类
public static VirtualFile chooseSourceRoot(final PackageWrapper targetPackage,
                                           final List<VirtualFile> contentSourceRoots,
                                           final PsiDirectory initialDirectory) {
  Project project = targetPackage.getManager().getProject();
  //ensure that there would be no duplicates: e.g. when one content root is subfolder of another root (configured via excluded roots)
  LinkedHashSet<PsiDirectory> targetDirectories = new LinkedHashSet<PsiDirectory>();
  Map<PsiDirectory, String> relativePathsToCreate = new HashMap<PsiDirectory,String>();
  buildDirectoryList(targetPackage, contentSourceRoots, targetDirectories, relativePathsToCreate);

  final PsiDirectory selectedDirectory = DirectoryChooserUtil.chooseDirectory(
    targetDirectories.toArray(new PsiDirectory[targetDirectories.size()]),
    initialDirectory,
    project,
    relativePathsToCreate
  );

  if (selectedDirectory == null) return null;
  final VirtualFile virt = selectedDirectory.getVirtualFile();
  final VirtualFile sourceRootForFile = ProjectRootManager.getInstance(project).getFileIndex().getSourceRootForFile(virt);
  LOG.assertTrue(sourceRootForFile != null);
  return sourceRootForFile;
}
 

import com.intellij.refactoring.PackageWrapper; //导入依赖的package包/类
public static PsiDirectory createPackageDirectoryInSourceRoot(PackageWrapper aPackage, final VirtualFile sourceRoot)
  throws IncorrectOperationException {
  final PsiDirectory[] directories = aPackage.getDirectories();
  for (PsiDirectory directory : directories) {
    if (VfsUtil.isAncestor(sourceRoot, directory.getVirtualFile(), false)) {
      return directory;
    }
  }
  String qNameToCreate = qNameToCreateInSourceRoot(aPackage, sourceRoot);
  final String[] shortNames = qNameToCreate.split("\\.");
  PsiDirectory current = aPackage.getManager().findDirectory(sourceRoot);
  LOG.assertTrue(current != null);
  for (String shortName : shortNames) {
    PsiDirectory subdirectory = current.findSubdirectory(shortName);
    if (subdirectory == null) {
      subdirectory = current.createSubdirectory(shortName);
    }
    current = subdirectory;
  }
  return current;
}
 

import com.intellij.refactoring.PackageWrapper; //导入依赖的package包/类
private void chooseDirectoryAndMove(Project project, PsiFile myFile) {
  try {
    PsiDirectory directory = MoveClassesOrPackagesUtil.chooseDestinationPackage(project, myTargetPackage, myFile.getContainingDirectory());

    if (directory == null) {
      return;
    }
    String error = RefactoringMessageUtil.checkCanCreateFile(directory, myFile.getName());
    if (error != null) {
      Messages.showMessageDialog(project, error, CommonBundle.getErrorTitle(), Messages.getErrorIcon());
      return;
    }
    new MoveClassesOrPackagesProcessor(
            project,
            ((PsiJavaFile) myFile).getClasses(),
            new SingleSourceRootMoveDestination(PackageWrapper.create(JavaDirectoryService.getInstance().getPackage(directory)), directory), false,
            false,
            null).run();
  }
  catch (IncorrectOperationException e) {
    LOG.error(e);
  }
}
 

import com.intellij.refactoring.PackageWrapper; //导入依赖的package包/类
@Nullable
public MoveDestination selectDirectory(final PackageWrapper targetPackage, final boolean showChooserWhenDefault) {
  final DirectoryChooser.ItemWrapper selectedItem = (DirectoryChooser.ItemWrapper)getComboBox().getSelectedItem();
  if (selectedItem == null || selectedItem == NULL_WRAPPER) {
    return new MultipleRootsMoveDestination(targetPackage);
  }
  final PsiDirectory selectedPsiDirectory = selectedItem.getDirectory();
  VirtualFile selectedDestination = selectedPsiDirectory.getVirtualFile();
  if (showChooserWhenDefault &&
      myInitialTargetDirectory != null && Comparing.equal(selectedDestination, myInitialTargetDirectory.getVirtualFile()) &&
      mySourceRoots.length > 1) {
    selectedDestination = MoveClassesOrPackagesUtil.chooseSourceRoot(targetPackage, mySourceRoots, myInitialTargetDirectory);
  }
  if (selectedDestination == null) return null;
  return new AutocreatingSingleSourceRootMoveDestination(targetPackage, selectedDestination);
}
 

import com.intellij.refactoring.PackageWrapper; //导入依赖的package包/类
public static VirtualFile chooseSourceRoot(final PackageWrapper targetPackage,
                                           final VirtualFile[] contentSourceRoots,
                                           final PsiDirectory initialDirectory) {
  Project project = targetPackage.getManager().getProject();
  //ensure that there would be no duplicates: e.g. when one content root is subfolder of another root (configured via excluded roots)
  LinkedHashSet<PsiDirectory> targetDirectories = new LinkedHashSet<PsiDirectory>();
  Map<PsiDirectory, String> relativePathsToCreate = new HashMap<PsiDirectory,String>();
  buildDirectoryList(targetPackage, contentSourceRoots, targetDirectories, relativePathsToCreate);

  final PsiDirectory selectedDirectory = DirectoryChooserUtil.chooseDirectory(
    targetDirectories.toArray(new PsiDirectory[targetDirectories.size()]),
    initialDirectory,
    project,
    relativePathsToCreate
  );

  if (selectedDirectory == null) return null;
  final VirtualFile virt = selectedDirectory.getVirtualFile();
  final VirtualFile sourceRootForFile = ProjectRootManager.getInstance(project).getFileIndex().getSourceRootForFile(virt);
  LOG.assertTrue(sourceRootForFile != null);
  return sourceRootForFile;
}
 

import com.intellij.refactoring.PackageWrapper; //导入依赖的package包/类
@Nullable
private MoveDestination selectDestination() {
  final String packageName = getTargetPackage().trim();
  if (packageName.length() > 0 && !PsiNameHelper.getInstance(myManager.getProject()).isQualifiedName(packageName)) {
    Messages.showErrorDialog(myProject, RefactoringBundle.message("please.enter.a.valid.target.package.name"),
                             RefactoringBundle.message("move.title"));
    return null;
  }
  RecentsManager.getInstance(myProject).registerRecentEntry(RECENTS_KEY, packageName);
  PackageWrapper targetPackage = new PackageWrapper(myManager, packageName);
  if (!targetPackage.exists()) {
    final int ret = Messages.showYesNoDialog(myProject, RefactoringBundle.message("package.does.not.exist", packageName),
                                             RefactoringBundle.message("move.title"), Messages.getQuestionIcon());
    if (ret != 0) return null;
  }

  return ((DestinationFolderComboBox)myDestinationFolderCB).selectDirectory(targetPackage, mySuggestToMoveToAnotherRoot);
}
 

import com.intellij.refactoring.PackageWrapper; //导入依赖的package包/类
@Override
protected void doOKAction() {
  RecentsManager.getInstance(myProject).registerRecentEntry(RECENTS_KEY, myPackageComponent.getText());
  final String packageName = getPackageName();

  final String[] errorString = new String[1];
  CommandProcessor.getInstance().executeCommand(myProject, new Runnable() {
    @Override
    public void run() {
      try {
        final PackageWrapper targetPackage = new PackageWrapper(PsiManager.getInstance(myProject), packageName);
        final MoveDestination destination = myDestinationCB.selectDirectory(targetPackage, false);
        if (destination == null) return;
        myTargetDirectory = ApplicationManager.getApplication().runWriteAction(new Computable<PsiDirectory>() {
          @Override
          public PsiDirectory compute() {
            return destination.getTargetDirectory(getBaseDir(packageName));
          }
        });
        if (myTargetDirectory == null) {
          errorString[0] = ""; // message already reported by PackageUtil
          return;
        }
        errorString[0] = RefactoringMessageUtil.checkCanCreateClass(myTargetDirectory, getClassName());
      }
      catch (IncorrectOperationException e) {
        errorString[0] = e.getMessage();
      }
    }
  }, CodeInsightBundle.message("create.directory.command"), null);

  if (errorString[0] != null) {
    if (errorString[0].length() > 0) {
      Messages.showMessageDialog(myProject, errorString[0], CommonBundle.getErrorTitle(), Messages.getErrorIcon());
    }
    return;
  }
  super.doOKAction();
}
 

import com.intellij.refactoring.PackageWrapper; //导入依赖的package包/类
@Override
protected void preparePackage() throws OperationFailedException {
  final String targetPackageName = getTargetPackageName();
  final PsiFile containingFile = mySourceClass.getContainingFile();
  final boolean fromDefaultPackage = containingFile instanceof PsiClassOwner && ((PsiClassOwner)containingFile).getPackageName().isEmpty(); 
  if (!(fromDefaultPackage && StringUtil.isEmpty(targetPackageName)) && !PsiNameHelper.getInstance(myProject).isQualifiedName(targetPackageName)) {
    throw new OperationFailedException("Invalid package name: " + targetPackageName);
  }
  final PsiPackage aPackage = JavaPsiFacade.getInstance(myProject).findPackage(targetPackageName);
  if (aPackage != null) {
    final PsiDirectory[] directories = aPackage.getDirectories(mySourceClass.getResolveScope());
    if (directories.length >= 1) {
      myTargetDirectory = getDirUnderSameSourceRoot(directories);
    }
  }
  
  final MoveDestination moveDestination =
    myDestinationFolderComboBox.selectDirectory(new PackageWrapper(PsiManager.getInstance(myProject), targetPackageName), false);
  if (moveDestination == null) return;

  myTargetDirectory = myTargetDirectory != null ? ApplicationManager.getApplication().runWriteAction(new Computable<PsiDirectory>() {
    @Override
    public PsiDirectory compute() {
      return moveDestination.getTargetDirectory(myTargetDirectory);
    }
  }) : null;

  if (myTargetDirectory == null) {
    throw new OperationFailedException(""); // message already reported by PackageUtil
  }
  String error = RefactoringMessageUtil.checkCanCreateClass(myTargetDirectory, getExtractedSuperName());
  if (error != null) {
    throw new OperationFailedException(error);
  }
}
 

import com.intellij.refactoring.PackageWrapper; //导入依赖的package包/类
public static PsiPackage doMovePackage(PsiPackage aPackage, MoveDestination moveDestination)
  throws IncorrectOperationException {
  final PackageWrapper targetPackage = moveDestination.getTargetPackage();

  final String newPrefix;
  if ("".equals(targetPackage.getQualifiedName())) {
    newPrefix = "";
  }
  else {
    newPrefix = targetPackage.getQualifiedName() + ".";
  }

  final String newPackageQualifiedName = newPrefix + aPackage.getName();

  // do actual move
  final GlobalSearchScope projectScope = GlobalSearchScope.projectScope(aPackage.getProject());
  PsiDirectory[] dirs = aPackage.getDirectories(projectScope);
  for (PsiDirectory dir : dirs) {
    final PsiDirectory targetDirectory = moveDestination.getTargetDirectory(dir);
    if (targetDirectory != null) {
      moveDirectoryRecursively(dir, targetDirectory);
    }
  }

  aPackage.handleQualifiedNameChange(newPackageQualifiedName);

  return JavaPsiFacade.getInstance(targetPackage.getManager().getProject()).findPackage(newPackageQualifiedName);
}
 

import com.intellij.refactoring.PackageWrapper; //导入依赖的package包/类
public static String getPackageName(PackageWrapper aPackage) {
  if (aPackage == null) {
    return null;
  }
  String name = aPackage.getQualifiedName();
  if (name.length() > 0) {
    return name;
  }
  else {
    return JavaFindUsagesProvider.DEFAULT_PACKAGE_NAME;
  }
}
 

import com.intellij.refactoring.PackageWrapper; //导入依赖的package包/类
@Nullable
public static PsiDirectory chooseDestinationPackage(Project project, String packageName, @Nullable PsiDirectory baseDir) {
  final PsiManager psiManager = PsiManager.getInstance(project);
  final PackageWrapper packageWrapper = new PackageWrapper(psiManager, packageName);
  final PsiPackage aPackage = JavaPsiFacade.getInstance(project).findPackage(packageName);
  PsiDirectory directory;

  PsiDirectory[] directories = aPackage != null ? aPackage.getDirectories() : null;
  final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(project).getFileIndex();
  final VirtualFile baseDirVirtualFile = baseDir != null ? baseDir.getVirtualFile() : null;
  final boolean isBaseDirInTestSources = baseDirVirtualFile != null && fileIndex.isInTestSourceContent(baseDirVirtualFile);
  if (directories != null && directories.length == 1 && (baseDirVirtualFile == null ||
                                                         fileIndex.isInTestSourceContent(directories[0].getVirtualFile()) == isBaseDirInTestSources)) {
    directory = directories[0];
  }
  else {
    final List<VirtualFile> contentSourceRoots = JavaProjectRootsUtil.getSuitableDestinationSourceRoots(project);
    if (contentSourceRoots.size() == 1 && (baseDirVirtualFile == null || fileIndex.isInTestSourceContent(contentSourceRoots.get(0)) == isBaseDirInTestSources)) {
      directory = ApplicationManager.getApplication().runWriteAction(new Computable<PsiDirectory>() {
        @Override
        public PsiDirectory compute() {
          return RefactoringUtil.createPackageDirectoryInSourceRoot(packageWrapper, contentSourceRoots.get(0));
        }
      });
    }
    else {
      final VirtualFile sourceRootForFile = chooseSourceRoot(packageWrapper, contentSourceRoots, baseDir);
      if (sourceRootForFile == null) return null;
      directory = ApplicationManager.getApplication().runWriteAction(new Computable<PsiDirectory>() {
        @Override
        public PsiDirectory compute() {
          return new AutocreatingSingleSourceRootMoveDestination(packageWrapper, sourceRootForFile).getTargetDirectory((PsiDirectory)null);
        }
      });
    }
  }
  return directory;
}
 

import com.intellij.refactoring.PackageWrapper; //导入依赖的package包/类
protected void doAction() {

    final List<PsiField> fields = getFieldsToExtract();
    final List<PsiMethod> methods = getMethodsToExtract();
    final List<PsiClass> classes = getClassesToExtract();
    final String newClassName = getClassName();
    final String packageName = getPackageName();

    Collections.sort(enumConstants, new Comparator<MemberInfo>() {
      public int compare(MemberInfo o1, MemberInfo o2) {
        return o1.getMember().getTextOffset() - o2.getMember().getTextOffset();
      }
    });
    final ExtractClassProcessor processor = new ExtractClassProcessor(sourceClass, fields, methods, classes, packageName,
                                                                      myDestinationFolderComboBox.selectDirectory(
                                                                        new PackageWrapper(PsiManager.getInstance(myProject), packageName),
                                                                        false),
                                                                      newClassName, myVisibilityPanel.getVisibility(),
                                                                      isGenerateAccessors(),
                                                                      isExtractAsEnum() ? enumConstants : Collections.<MemberInfo>emptyList());
    processor.setExtractInnerClass(createInner.isSelected());
    if (processor.getCreatedClass() == null) {
      Messages.showErrorDialog(myVisibilityPanel, "Unable to create class with the given name");
      classNameField.requestFocusInWindow();
      return;
    }
    invokeRefactoring(processor);
  }
 

import com.intellij.refactoring.PackageWrapper; //导入依赖的package包/类
protected void doOKAction(){
  final String packageName = myTfPackage.getText();
  final String className = getClassName();

  final String[] errorString = new String[1];
  final PsiManager manager = PsiManager.getInstance(myProject);
  final PsiNameHelper nameHelper = PsiNameHelper.getInstance(manager.getProject());
  if (packageName.length() > 0 && !nameHelper.isQualifiedName(packageName)) {
    errorString[0] = RefactoringBundle.message("invalid.target.package.name.specified");
  } else if (className != null && className.isEmpty()) {
    errorString[0] = RefactoringBundle.message("no.class.name.specified");
  } else {
    if (!nameHelper.isIdentifier(className)) {
      errorString[0] = RefactoringMessageUtil.getIncorrectIdentifierMessage(className);
    }
    else if (!myDoClone) {
      try {
        final PackageWrapper targetPackage = new PackageWrapper(manager, packageName);
        myDestination = myDestinationCB.selectDirectory(targetPackage, false);
        if (myDestination == null) return;
      }
      catch (IncorrectOperationException e) {
        errorString[0] = e.getMessage();
      }
    }
    RecentsManager.getInstance(myProject).registerRecentEntry(RECENTS_KEY, packageName);
  }

  if (errorString[0] != null) {
    if (errorString[0].length() > 0) {
      Messages.showMessageDialog(myProject, errorString[0], RefactoringBundle.message("error.title"), Messages.getErrorIcon());
    }
    myNameField.requestFocusInWindow();
    return;
  }
  CopyFilesOrDirectoriesDialog.saveOpenInEditorState(myOpenInEditorCb.isSelected());
  super.doOKAction();
}
 

import com.intellij.refactoring.PackageWrapper; //导入依赖的package包/类
public static String qNameToCreateInSourceRoot(PackageWrapper aPackage, final VirtualFile sourceRoot) throws IncorrectOperationException {
  String targetQName = aPackage.getQualifiedName();
  String sourceRootPackage =
    ProjectRootManager.getInstance(aPackage.getManager().getProject()).getFileIndex().getPackageNameByDirectory(sourceRoot);
  if (!canCreateInSourceRoot(sourceRootPackage, targetQName)) {
    throw new IncorrectOperationException(
      "Cannot create package '" + targetQName + "' in source folder " + sourceRoot.getPresentableUrl());
  }
  String result = targetQName.substring(sourceRootPackage.length());
  if (StringUtil.startsWithChar(result, '.')) result = result.substring(1);  // remove initial '.'
  return result;
}
 

import com.intellij.refactoring.PackageWrapper; //导入依赖的package包/类
@Nullable
public static PsiDirectory findPackageDirectoryInSourceRoot(PackageWrapper aPackage, final VirtualFile sourceRoot) {
  final PsiDirectory[] directories = aPackage.getDirectories();
  for (PsiDirectory directory : directories) {
    if (VfsUtil.isAncestor(sourceRoot, directory.getVirtualFile(), false)) {
      return directory;
    }
  }
  String qNameToCreate;
  try {
    qNameToCreate = qNameToCreateInSourceRoot(aPackage, sourceRoot);
  }
  catch (IncorrectOperationException e) {
    return null;
  }
  final String[] shortNames = qNameToCreate.split("\\.");
  PsiDirectory current = aPackage.getManager().findDirectory(sourceRoot);
  LOG.assertTrue(current != null);
  for (String shortName : shortNames) {
    PsiDirectory subdirectory = current.findSubdirectory(shortName);
    if (subdirectory == null) {
      return null;
    }
    current = subdirectory;
  }
  return current;
}
 

import com.intellij.refactoring.PackageWrapper; //导入依赖的package包/类
private void move(final PsiElement psiElement, String packageName) {
  VirtualFile pkgFile = mySource.createPackageDir(packageName);
  final PsiDirectory toDir = PsiManager.getInstance(myProject).findDirectory(pkgFile);
  assertNotNull(toDir);
  new WriteCommandAction(myProject, psiElement.getContainingFile()) {
    @Override
    protected void run(@NotNull Result result) throws Throwable {
      PackageWrapper wrapper = PackageWrapper.create(JavaDirectoryService.getInstance().getPackage(toDir));
      new MoveClassesOrPackagesProcessor(myProject, new PsiElement[]{psiElement},
                                         new SingleSourceRootMoveDestination(wrapper, toDir),
                                         false, false, null).run();
    }
  }.executeSilently();
}
 

import com.intellij.refactoring.PackageWrapper; //导入依赖的package包/类
private void moveClass(final String className, final String newPackageName) throws Throwable {
  new WriteCommandAction.Simple(myFixture.getProject()) {
    @Override
    protected void run() throws Throwable {
      PsiClass aClass = JavaPsiFacade.getInstance(getProject()).findClass(className, GlobalSearchScope.projectScope(getProject()));
      PsiPackage aPackage = JavaPsiFacade.getInstance(getProject()).findPackage(newPackageName);

      final PsiDirectory[] dirs = aPackage.getDirectories();
      assertEquals(dirs.length, 1);

      new MoveClassesOrPackagesProcessor(getProject(), new PsiElement[]{aClass}, new SingleSourceRootMoveDestination(
        PackageWrapper.create(JavaDirectoryService.getInstance().getPackage(dirs[0])), dirs[0]), true, true, null).run();
    }
  }.execute().throwException();
}