import com.intellij.ide.wizard.Step; //导入依赖的package包/类
protected Project createProjectFromTemplate(@NotNull String group, @Nullable String name, @Nullable Consumer<Step> adjuster) throws IOException {
  runWizard(group, name, null, adjuster);
  try {
    myCreatedProject = NewProjectUtil.createFromWizard(myWizard, null);
  }
  catch (Throwable e) {
    myCreatedProject = ContainerUtil.find(myProjectManager.getOpenProjects(), new Condition<Project>() {
      @Override
      public boolean value(Project project) {
        return myWizard.getProjectName().equals(project.getName());
      }
    });
    throw new RuntimeException(e);
  }
  assertNotNull(myCreatedProject);
  UIUtil.dispatchAllInvocationEvents();

  Project[] projects = myProjectManager.getOpenProjects();
  assertEquals(Arrays.asList(projects).toString(), 2, projects.length);
  return myCreatedProject;
}
 

import com.intellij.ide.wizard.Step; //导入依赖的package包/类
protected void runWizard(@Nullable Consumer<Step> adjuster) {
  while (true) {
    ModuleWizardStep currentStep = myWizard.getCurrentStepObject();
    if (adjuster != null) {
      adjuster.consume(currentStep);
    }
    if (myWizard.isLast()) {
      break;
    }
    myWizard.doNextAction();
    if (currentStep == myWizard.getCurrentStepObject()) {
      throw new RuntimeException(currentStep + " is not validated");
    }
  }
  myWizard.doFinishAction();
}
 

import com.intellij.ide.wizard.Step; //导入依赖的package包/类
@Nullable
private Step showNextStep(@Nullable AndroidStudioWizardPath path) {
  Step newStep;
  if (path != null && path.hasNext()) {
    newStep = path.next();
  }
  else {
    newStep = null;
    while (myPathListIterator.hasNext() && newStep == null) {
      myCurrentPath = myPathListIterator.next();
      assert myCurrentPath != null;
      myCurrentPath.onPathStarted(true /* fromBeginning */);
      newStep = myCurrentPath.getCurrentStep();
    }
  }
  if (newStep != null) {
    showStep(newStep);
  }
  return newStep;
}
 

import com.intellij.ide.wizard.Step; //导入依赖的package包/类
@Override
protected boolean doQuickImport(VirtualFile file, WizardContext wizardContext) {
  AddModuleWizard dialog = new AddModuleWizard(null, file.getPath(), new GradleProjectImportProvider(getBuilder()));
  getBuilder().prepare(wizardContext);
  getBuilder().getControl(null).setLinkedProjectPath(file.getPath());
  dialog.getWizardContext().setProjectBuilder(getBuilder());
  dialog.navigateToStep(new Function<Step, Boolean>() {
    @Override
    public Boolean fun(Step step) {
      return step instanceof SelectExternalProjectStep;
    }
  });
  if (StringUtil.isEmpty(wizardContext.getProjectName())) {
    final String projectName = dialog.getWizardContext().getProjectName();
    if (!StringUtil.isEmpty(projectName)) {
      wizardContext.setProjectName(projectName);
    }
  }

  dialog.show();
  return dialog.isOK();
}
 

import com.intellij.ide.wizard.Step; //导入依赖的package包/类
protected Module importProjectFrom(String path, Consumer<Step> adjuster, ProjectImportProvider... providers) {
  Module module = importFrom(path, null, adjuster, providers);
  if (module != null) {
    myCreatedProject = module.getProject();
  }
  return module;
}
 

import com.intellij.ide.wizard.Step; //导入依赖的package包/类
private Module importFrom(String path,
                          @Nullable Project project, Consumer<Step> adjuster,
                          final ProjectImportProvider... providers) {
  VirtualFile file = LocalFileSystem.getInstance().refreshAndFindFileByPath(path);
  assertNotNull("Can't find " + path, file);
  assertTrue(providers[0].canImport(file, project));

  //noinspection unchecked
  myWizard = (T)ImportModuleAction.createImportWizard(project, null, file, providers);
  assertNotNull(myWizard);
  if (myWizard.getStepCount() > 0) {
    runWizard(adjuster);
  }
  return ContainerUtil.getFirstItem(ImportModuleAction.createFromWizard(project, myWizard));
}
 

import com.intellij.ide.wizard.Step; //导入依赖的package包/类
/**
 * Allows to ask current wizard to move to the desired step.
 *
 * @param filter  closure that allows to indicate target step - is called with each of registered steps and is expected
 *                to return <code>true</code> for the step to go to
 * @return        <code>true</code> if current wizard is navigated to the target step; <code>false</code> otherwise
 */
public boolean navigateToStep(@NotNull Function<Step, Boolean> filter) {
  for (int i = 0, myStepsSize = mySteps.size(); i < myStepsSize; i++) {
    ModuleWizardStep step = mySteps.get(i);
    if (filter.fun(step) != Boolean.TRUE) {
      continue;
    }

    // Update current step.
    myCurrentStep = i;
    updateStep();
    return true;
  }
  return false;
}
 

import com.intellij.ide.wizard.Step; //导入依赖的package包/类
private void showStep(@NotNull Step step) {
  JComponent component = step.getComponent();
  addStepIfNecessary(step);
  Icon icon = step.getIcon();
  myHost.setIcon(icon);
  ((CardLayout)myContentPanel.getLayout()).show(myContentPanel, myComponentToIdMap.get(component));

  JComponent focusedComponent = step.getPreferredFocusedComponent();
  if (focusedComponent != null) {
    IdeFocusManager.findInstanceByComponent(focusedComponent).requestFocus(focusedComponent, false);
  }
}
 

import com.intellij.ide.wizard.Step; //导入依赖的package包/类
/**
 * Commit the current step and move to the next step. Subclasses should rarely need to override
 * this method.
 */
public final void doNextAction() {
  if (!canAdvance()) {
    myHost.shakeWindow();
    return;
  }
  Step newStep = showNextStep(myCurrentPath);
  if (newStep == null) {
    doFinishAction();
  }
}
 

import com.intellij.ide.wizard.Step; //导入依赖的package包/类
@Nullable
public final JComponent getPreferredFocusedComponent() {
  Step currentStep = myCurrentPath.getCurrentStep();
  if (currentStep != null) {
    return currentStep.getPreferredFocusedComponent();
  }
  else {
    return null;
  }
}
 

import com.intellij.ide.wizard.Step; //导入依赖的package包/类
private void prepareForShow() {
  // All steps must be included so the window can be sized correctly
  for (AndroidStudioWizardPath path : myPaths) {
    for (Step step : path.getAllSteps()) {
      addStepIfNecessary(step);
    }
  }

  SwingUtilities.getWindowAncestor(myContentPanel).pack();
}
 

import com.intellij.ide.wizard.Step; //导入依赖的package包/类
private void addStepIfNecessary(Step step) {
  JComponent component = step.getComponent();
  String id = myComponentToIdMap.get(component);
  if (id == null) {
    id = String.valueOf(myComponentToIdMap.size());
    myComponentToIdMap.put(component, id);
    myContentPanel.add(component, id);
  }
}
 

import com.intellij.ide.wizard.Step; //导入依赖的package包/类
@Override
protected boolean doQuickImport(VirtualFile file, WizardContext wizardContext) {
  final GradleProjectImportProvider projectImportProvider = new GradleProjectImportProvider(getBuilder());
  getBuilder().setFileToImport(file.getPath());
  getBuilder().prepare(wizardContext);
  getBuilder().getControl(null).setLinkedProjectPath(file.getPath());

  final boolean result;
  if (ApplicationManager.getApplication().isHeadlessEnvironment()) {
    result = setupGradleProjectSettingsInHeadlessMode(file, projectImportProvider, wizardContext);
  }
  else {
    AddModuleWizard dialog = new AddModuleWizard(null, file.getPath(), projectImportProvider);
    dialog.getWizardContext().setProjectBuilder(getBuilder());
    dialog.navigateToStep(new Function<Step, Boolean>() {
      @Override
      public Boolean fun(Step step) {
        return step instanceof SelectExternalProjectStep;
      }
    });
    result = dialog.showAndGet();
  }
  if (result && getBuilder().getExternalProjectNode() != null) {
    wizardContext.setProjectName(getBuilder().getExternalProjectNode().getData().getInternalName());
  }
  return result;
}
 

import com.intellij.ide.wizard.Step; //导入依赖的package包/类
/**
 * Allows to ask current wizard to move to the desired step.
 *
 * @param filter closure that allows to indicate target step - is called with each of registered steps and is expected
 *               to return <code>true</code> for the step to go to
 * @return <code>true</code> if current wizard is navigated to the target step; <code>false</code> otherwise
 */
public boolean navigateToStep(@Nonnull Function<Step, Boolean> filter) {
  for (int i = 0, myStepsSize = mySteps.size(); i < myStepsSize; i++) {
    ModuleWizardStep step = mySteps.get(i);
    if (filter.fun(step) != Boolean.TRUE) {
      continue;
    }

    // Update current step.
    myCurrentStep = i;
    updateStep();
    return true;
  }
  return false;
}
 

import com.intellij.ide.wizard.Step; //导入依赖的package包/类
@Nullable
protected Module createModuleFromTemplate(String group, String name, @Nullable Consumer<Step> adjuster) throws IOException {
  runWizard(group, name, getProject(), adjuster);
  return createModuleFromWizard();
}
 

import com.intellij.ide.wizard.Step; //导入依赖的package包/类
protected Project createProject(Consumer<Step> adjuster) throws IOException {
  createWizard(null);
  runWizard(adjuster);
  myCreatedProject = NewProjectUtil.createFromWizard(myWizard, null);
  return myCreatedProject;
}
 

import com.intellij.ide.wizard.Step; //导入依赖的package包/类
@Nullable
@Override
public Step next() {
  return navigate(1);
}
 

import com.intellij.ide.wizard.Step; //导入依赖的package包/类
private Step navigate(int direction) {
  myCurrentStep = findNext(myCurrentStep, direction);
  assert myCurrentStep >= 0;
  updateWizard();
  return mySteps.get(myCurrentStep);
}
 

import com.intellij.ide.wizard.Step; //导入依赖的package包/类
@Nullable
@Override
public Step previous() {
  return navigate(-1);
}
 

import com.intellij.ide.wizard.Step; //导入依赖的package包/类
public void testGradleProject() throws Exception {
  final String projectName = "testProject";
  Project project = createProject(new Consumer<Step>() {
    @Override
    public void consume(Step step) {
      if (step instanceof ProjectTypeStep) {
        assertTrue(((ProjectTypeStep)step).setSelectedTemplate("Gradle", null));
        List<ModuleWizardStep> steps = myWizard.getSequence().getSelectedSteps();
        assertEquals(5, steps.size());
        final ProjectBuilder projectBuilder = myWizard.getProjectBuilder();
        assertInstanceOf(projectBuilder, GradleModuleBuilder.class);
        ((GradleModuleBuilder)projectBuilder).setName(projectName);
      }
    }
  });

  assertEquals(projectName, project.getName());
  Module[] modules = ModuleManager.getInstance(project).getModules();
  assertEquals(1, modules.length);
  final Module module = modules[0];
  assertTrue(ModuleRootManager.getInstance(module).isSdkInherited());
  assertEquals(projectName, module.getName());

  VirtualFile root = ProjectRootManager.getInstance(project).getContentRoots()[0];
  VirtualFile settingsScript = VfsUtilCore.findRelativeFile("settings.gradle", root);
  assertNotNull(settingsScript);
  assertEquals(String.format("rootProject.name = '%s'\n\n", projectName),
               StringUtil.convertLineSeparators(VfsUtilCore.loadText(settingsScript)));

  VirtualFile buildScript = VfsUtilCore.findRelativeFile("build.gradle", root);
  assertNotNull(buildScript);
  assertEquals("group '" + projectName + "'\n" +
               "version '1.0-SNAPSHOT'\n" +
               "\n" +
               "apply plugin: 'java'\n" +
               "\n" +
               "sourceCompatibility = 1.5\n" +
               "\n" +
               "repositories {\n" +
               "    mavenCentral()\n" +
               "}\n" +
               "\n" +
               "dependencies {\n" +
               "    testCompile group: 'junit', name: 'junit', version: '4.11'\n" +
               "}\n",
               StringUtil.convertLineSeparators(VfsUtilCore.loadText(buildScript)));
}