Java WizardContext类代码示例

import com.intellij.ide.util.projectWizard.WizardContext; //导入依赖的package包/类
private AddModuleWizard getWizard(final Project project) throws ConfigurationException {
    final HybrisProjectImportProvider provider = getHybrisProjectImportProvider();
    final String basePath = project.getBasePath();
    final String projectName = project.getName();
    final Sdk jdk = ProjectRootManager.getInstance(project).getProjectSdk();
    final String compilerOutputUrl = CompilerProjectExtension.getInstance(project).getCompilerOutputUrl();
    final HybrisProjectSettings settings = HybrisProjectSettingsComponent.getInstance(project).getState();

    final AddModuleWizard wizard = new AddModuleWizard(null, basePath, provider) {

        protected void init() {
            // non GUI mode
        }
    };
    final WizardContext wizardContext = wizard.getWizardContext();
    wizardContext.setProjectJdk(jdk);
    wizardContext.setProjectName(projectName);
    wizardContext.setCompilerOutputDirectory(compilerOutputUrl);
    final StepSequence stepSequence = wizard.getSequence();
    for (ModuleWizardStep step : stepSequence.getAllSteps()) {
        if (step instanceof NonGuiSupport) {
            ((NonGuiSupport) step).nonGuiModeImport(settings);
        }
    }
    return wizard;
}
 

import com.intellij.ide.util.projectWizard.WizardContext; //导入依赖的package包/类
@Override
public boolean doQuickImport(final VirtualFile file, final WizardContext wizardContext) {
    this.getBuilder().cleanup();
    this.getBuilder().setRootProjectDirectory(VfsUtil.virtualToIoFile(file.getParent()));

    final List<HybrisModuleDescriptor> projects = this.getBuilder().getList();
    if (null == projects || 1 != projects.size()) {
        return false;
    }

    try {
        this.getBuilder().setList(projects);
    } catch (ConfigurationException e) {
        LOG.error(e);
    }

    wizardContext.setProjectName(projects.get(0).getName());

    return true;
}
 

import com.intellij.ide.util.projectWizard.WizardContext; //导入依赖的package包/类
@Override
public ModuleWizardStep[] createSteps(WizardContext context) {
  if (myProjectImport) {
    return new ModuleWizardStep[]{
      new AdtImportLocationStep(context),
      new AdtImportPrefsStep(context),
      new AdtWorkspaceForm(context),
      new AdtImportSdkStep(context),
      new AdtRepositoriesStep(context),
      new AdtImportWarningsStep(context)
    };
  } else {
    return new ModuleWizardStep[]{
      new AdtImportPrefsStep(context),
      new AdtWorkspaceForm(context),
      new AdtImportSdkStep(context),
      new AdtRepositoriesStep(context),
      new AdtImportWarningsStep(context)
    };
  }
}
 

import com.intellij.ide.util.projectWizard.WizardContext; //导入依赖的package包/类
public static MultiMap<TemplatesGroup, ProjectTemplate> getTemplatesMap(WizardContext context) {
  ProjectTemplatesFactory[] factories = ProjectTemplatesFactory.EP_NAME.getExtensions();
  final MultiMap<TemplatesGroup, ProjectTemplate> groups = new MultiMap<TemplatesGroup, ProjectTemplate>();
  for (ProjectTemplatesFactory factory : factories) {
    for (String group : factory.getGroups()) {
      ProjectTemplate[] templates = factory.createTemplates(group, context);
      List<ProjectTemplate> values = Arrays.asList(templates);
      if (!values.isEmpty()) {
        Icon icon = factory.getGroupIcon(group);
        String parentGroup = factory.getParentGroup(group);
        TemplatesGroup templatesGroup = new TemplatesGroup(group, null, icon, factory.getGroupWeight(group), parentGroup, group, null);
        groups.putValues(templatesGroup, values);
      }
    }
  }
  return groups;
}
 

import com.intellij.ide.util.projectWizard.WizardContext; //导入依赖的package包/类
public FrameworkBasedOptionsStep(T provider, final B builder, WizardContext context) {
  myContext = context;
  LibrariesContainer container = LibrariesContainerFactory.createContainer(myContext.getProject());
  myBuilder = builder;
  myFrameworkSupportModel = new FrameworkSupportModelBase(context.getProject(), myBuilder, container) {
    @NotNull
    @Override
    public String getBaseDirectoryForLibrariesPath() {
      return StringUtil.notNullize(builder.getContentEntryPath());
    }
  };
  //noinspection AbstractMethodCallInConstructor
  myConfigurable = createConfigurable(provider, myFrameworkSupportModel);
  myFrameworkSupportModel.selectFramework(provider, true);

  builder.addModuleConfigurationUpdater(new ModuleBuilder.ModuleConfigurationUpdater() {
    @Override
    public void update(@NotNull Module module, @NotNull ModifiableRootModel rootModel) {
      myConfigurable.addSupport(module, rootModel, null);
    }
  });

  myPanel = new JPanel(new BorderLayout(0, 4));
  myPanel.add(myConfigurable.getComponent(), BorderLayout.CENTER);
  updateDataModel();
}
 

import com.intellij.ide.util.projectWizard.WizardContext; //导入依赖的package包/类
public ImportSourceModulePath(@Nullable VirtualFile importSource,
                              @NotNull NewModuleWizardState wizardState,
                              @NotNull WizardContext context,
                              @Nullable Icon sidePanelIcon,
                              @Nullable TemplateWizardStep.UpdateListener listener) {
  myWizardState = wizardState;
  myContext = context;
  List<ModuleWizardStep> steps = Lists.newLinkedList();
  ImportSourceLocationStep locationStep = new ImportSourceLocationStep(context, importSource,
                                                                       wizardState, sidePanelIcon, listener);
  steps.add(locationStep);
  for (ModuleImporter importer : ModuleImporter.getAllImporters(myContext)) {
    steps.addAll(importer.createWizardSteps());
  }
  mySteps = steps;
}
 

import com.intellij.ide.util.projectWizard.WizardContext; //导入依赖的package包/类
@NotNull
@Override
public ProjectTemplate[] createTemplates(@Nullable String group, WizardContext context) {
    return new ProjectTemplate[]{
            new TYPO3CMSClassicLayoutDirectoryProjectGenerator(),
            new TYPO3CMSComposerLayoutDirectoryProjectGenerator()
    };
}
 

import com.intellij.ide.util.projectWizard.WizardContext; //导入依赖的package包/类
@Override
public ModuleWizardStep[] createSteps(final WizardContext context) {
    final ProjectWizardStepFactory stepFactory = ProjectWizardStepFactory.getInstance();

    return new ModuleWizardStep[]{
        new CheckRequiredPluginsStep(context),
        new DiscountImportstep(context),
        new InformationStep(context),
        new HybrisWorkspaceRootStep(context),
        new SelectHybrisModulesToImportStep(context),
        new SelectOtherModulesToImportStep(context),
        stepFactory.createProjectJdkStep(context)
    };
}
 

import com.intellij.ide.util.projectWizard.WizardContext; //导入依赖的package包/类
@NotNull
@Override
public ProjectTemplate[] createTemplates(@Nullable String group, WizardContext context) {
  final ArrayList<EduIntelliJProjectTemplate> templates = new ArrayList<>();
  final List<Course> courses = EduCourseUpdater.getInstance().getRemoteCourses();
  for (Course course : courses) {
    templates.add(new EduRemoteCourseTemplate(course));
  }
  Collections.addAll(templates, ApplicationManager.getApplication().getExtensions(EduIntelliJProjectTemplate.EP_NAME));
  return templates.toArray(new ProjectTemplate[templates.size()]);
}
 

import com.intellij.ide.util.projectWizard.WizardContext; //导入依赖的package包/类
@Override
public ModuleWizardStep[] createWizardSteps(@NotNull WizardContext wizardContext,
                                            @NotNull ModulesProvider modulesProvider) {
    ConfigureProcessingProject projectConfig =  new ConfigureProcessingProject(wizardContext);

    ModuleWizardStep[] wizardSteps = new ModuleWizardStep[1];
    wizardSteps[0] = projectConfig;

    return wizardSteps;
}
 

import com.intellij.ide.util.projectWizard.WizardContext; //导入依赖的package包/类
public ModuleWizardStep[] createSteps(WizardContext context) {
    final ProjectWizardStepFactory stepFactory = ProjectWizardStepFactory.getInstance();
    return new ModuleWizardStep[]{
            stepFactory.createProjectJdkStep(context),
            new ProcessingSketchRootSelectStep(context),
            new ConfigureProcessingProject(context)
    };
}
 

import com.intellij.ide.util.projectWizard.WizardContext; //导入依赖的package包/类
@Override
@Nullable
public ModuleWizardStep getCustomOptionsStep(WizardContext context, Disposable parentDisposable) {
    setProject(context.getProject());
    GravIntroWizardStep step = new GravIntroWizardStep(this);
    Disposer.register(parentDisposable, step);
    return step;
}
 

import com.intellij.ide.util.projectWizard.WizardContext; //导入依赖的package包/类
@Override
    public ModuleWizardStep[] createWizardSteps(@NotNull WizardContext wizardContext, @NotNull ModulesProvider modulesProvider) {
        return new ModuleWizardStep[]{
//                new GravIntroWizardStep(this),
//                new GravModuleWizardStep(this)
        };
    }
 

import com.intellij.ide.util.projectWizard.WizardContext; //导入依赖的package包/类
@Nullable
@Override
public ModuleWizardStep getCustomOptionsStep(WizardContext context, Disposable parentDisposable) {
    MuleVersionConfiguration step = new MuleVersionConfiguration(this, muleVersion);
    Disposer.register(parentDisposable, step);
    return step;
}
 

import com.intellij.ide.util.projectWizard.WizardContext; //导入依赖的package包/类
public LuaSdkSelectStep(@NotNull final LuaModuleBuilder moduleBuilder, @Nullable final Icon icon,
                        @Nullable final String helpId, @NotNull final WizardContext context) {
    super();
    myIcon = icon;
    myModuleBuilder = moduleBuilder;
    myContext = context;
    myHelp = helpId;
}