com.intellij.openapi.roots.ui.configuration.ModulesProvider Java Examples

@Override
public void processImport(Module module) {
    Project project = module.getProject();
    File gradleFile = null;

    for(VirtualFile virtualFile : ModuleRootManager.getInstance(module).getContentRoots()) {
        File baseDir = VfsUtilCore.virtualToIoFile(virtualFile);
        File file = new File(baseDir, "build.gradle");
        if (file.exists()) {
            gradleFile = file;
            break;
        }
    }

    if (gradleFile != null) {
        ProjectImportProvider gradleProjectImportProvider = getGradleProjectImportProvider();
        ProjectImportBuilder gradleProjectImportBuilder = gradleProjectImportProvider.getBuilder();
        AddModuleWizard wizard = new AddModuleWizard(project, gradleFile.getPath(), new ProjectImportProvider[]{gradleProjectImportProvider});
        if (wizard.getStepCount() == 0 || wizard.showAndGet()) {
            gradleProjectImportBuilder.commit(project, (ModifiableModuleModel)null, (ModulesProvider)null);
        }
    }
}
 

@javax.annotation.Nullable
public Library findLibrary(@Nonnull PackagingElementResolvingContext context) {
  if (myModuleName == null) {
    return context.findLibrary(myLevel, myLibraryName);
  }
  final ModulesProvider modulesProvider = context.getModulesProvider();
  final Module module = modulesProvider.getModule(myModuleName);
  if (module != null) {
    for (OrderEntry entry : modulesProvider.getRootModel(module).getOrderEntries()) {
      if (entry instanceof LibraryOrderEntry) {
        final LibraryOrderEntry libraryEntry = (LibraryOrderEntry)entry;
        if (libraryEntry.isModuleLevel()) {
          final String libraryName = libraryEntry.getLibraryName();
          if (libraryName != null && libraryName.equals(myLibraryName)) {
            return libraryEntry.getLibrary();
          }
        }
      }
    }
  }
  return null;
}
 

private void setupLibraries(Project project, ModifiableModelsProvider modelsProvider, ModulesProvider modulesProvider, List<LibraryData> libraries) {
  LibraryTable.ModifiableModel librariesModel = modelsProvider.getLibraryTableModifiableModel(project);

  for(LibraryData lib:libraries) {
    VirtualFile root = LocalFileSystem.getInstance().findFileByPath(lib.getClasspath());
    if(root != null) {
      LibraryImpl library = (LibraryImpl)librariesModel.createLibrary(lib.getName());
      LibraryEx.ModifiableModelEx model = library.getModifiableModel();
      model.setKind(HaxeLibraryType.HAXE_LIBRARY);
      model.addRoot(root, OrderRootType.CLASSES);
      model.addRoot(root, OrderRootType.SOURCES);
      model.commit();

      for(Module module:modulesProvider.getModules()) {
        ModifiableRootModel moduleModel = modelsProvider.getModuleModifiableModel(module);
        moduleModel.addLibraryEntry(library);
        moduleModel.commit();
      }
    }
  }

  librariesModel.commit();
}
 

@Override
public void updateProject(@NotNull Project project, @NotNull ModifiableModelsProvider modelsProvider, @NotNull ModulesProvider modulesProvider) {
  if(myLibraries != null && !myLibraries.isEmpty()) {
    List<LibraryData> libraries = collectLibraries(project);
    if(!libraries.isEmpty()) {
      setupLibraries(project, modelsProvider, modulesProvider, libraries);
    }
  }
  if(myHxml != null) {
    Module rootModule = getRootModule(modelsProvider, modulesProvider);
    if(rootModule != null) {
      setupCompilationSettings(rootModule, modelsProvider.getModuleModifiableModel(rootModule));
      setupHxmlRunConfigurations(rootModule);
    }
  }
}
 

private void link(@NotNull VirtualFile projectFile, @NotNull Project project, AddModuleWizard dialog) {
  if (dialog == null) return;

  ProjectBuilder builder = dialog.getBuilder(project);
  if (builder == null) return;

  try {
    ApplicationManager.getApplication().runWriteAction(() -> {
      Optional.ofNullable(dialog.getNewProjectJdk())
        .ifPresent(jdk -> NewProjectUtil.applyJdkToProject(project, jdk));

      URI output = projectDir(projectFile).resolve(".out").toUri();
      Optional.ofNullable(CompilerProjectExtension.getInstance(project))
        .ifPresent(ext -> ext.setCompilerOutputUrl(output.toString()));
    });

    builder.commit(project, null, ModulesProvider.EMPTY_MODULES_PROVIDER);
    project.putUserData(ExternalSystemDataKeys.NEWLY_IMPORTED_PROJECT, Boolean.TRUE);

    project.save();
  }
  finally {
    builder.cleanup();
  }
}
 

@Override
public ModuleWizardStep[] createWizardSteps(WizardContext wizardContext, ModulesProvider modulesProvider) {
    RoboVmModuleWizardStep wizardStep = new RoboVmModuleWizardStep(this, wizardContext, modulesProvider);

    if (!robovmDir.isEmpty()) {
        wizardStep.disableBuildSystem();
        buildSystem = BuildSystem.Gradle;
    }

    if (!robovmDir.isEmpty() && !RoboVmPlugin.isAndroidSdkSetup()) {
        RoboVmAndroidModuleWizardStep androidStep = new RoboVmAndroidModuleWizardStep(this, wizardContext,
                modulesProvider);
        return new ModuleWizardStep[] { androidStep, wizardStep };
    } else {
        return new ModuleWizardStep[] { wizardStep };
    }
}
 

public ModuleWizardStep[] createWizardSteps(WizardContext wizardContext, CppModuleBuilder cppModuleBuilder, ModulesProvider modulesProvider) {
  final List<Sdk> list = CppSdkType.getInstance().getCppSdks();
  final ModuleWizardStep sourceModuleWizardStep = ProjectWizardStepFactory.getInstance().createSourcePathsStep(wizardContext, cppModuleBuilder, null, null);
  final ModuleWizardStep createSampleCode = new CreateEntryCodeStep(cppModuleBuilder);

  if (list.size() == 0) {
    return new ModuleWizardStep[] { new ChooseCppSdkStep(cppModuleBuilder, wizardContext),sourceModuleWizardStep, createSampleCode };
  }
  return new ModuleWizardStep[] { sourceModuleWizardStep, createSampleCode };
}
 

@Override
public ModuleWizardStep[] createWizardSteps(@NotNull WizardContext wizardContext, @NotNull ModulesProvider modulesProvider) {
	SelectionContext.clearAllSet();
	CrudTableStep tableStep = new CrudTableStep(new CrudTableView());
	CrudDbStep dbStep = new CrudDbStep(new CrudDbView(), tableStep);
	CrudConnStep connStep = new CrudConnStep(new CrudConnView(), dbStep);
	return new ModuleWizardStep[]{
			connStep,
			dbStep,
			tableStep,
			new CrudProjectInfoStep()
	};
}
 

public static boolean hasModuleExtension(@Nonnull ModulesProvider modulesProvider, @Nonnull Class<? extends ModuleExtension> clazz) {
  for (Module module : modulesProvider.getModules()) {
    ModuleRootModel rootModel = modulesProvider.getRootModel(module);
    if (rootModel == null) {
      continue;
    }

    ModuleExtension extension = rootModel.getExtension(clazz);
    if (extension != null) {
      return true;
    }
  }
  return false;
}
 

@Override
@javax.annotation.Nullable
public Module findModule(PackagingElementResolvingContext context) {
  final Module module = NamedPointerUtil.get(myModulePointer);
  final ModulesProvider modulesProvider = context.getModulesProvider();
  if (module != null) {
    if (modulesProvider instanceof DefaultModulesProvider//optimization
        || ArrayUtil.contains(module, modulesProvider.getModules())) {
      return module;
    }
  }
  return modulesProvider.getModule(myModulePointer.getName());
}
 

private List<Module> getSuitableModules(ArtifactEditorContext context) {
  ModulesProvider modulesProvider = context.getModulesProvider();
  ArrayList<Module> modules = new ArrayList<Module>();
  for (Module module : modulesProvider.getModules()) {
    if (isSuitableModule(modulesProvider, module)) {
      modules.add(module);
    }
  }
  return modules;
}
 

public boolean isSuitableModule(ModulesProvider modulesProvider, Module module) {
  for (ContentEntry entry : modulesProvider.getRootModel(module).getContentEntries()) {
    if (entry.getFolders(Predicates.equalTo(myContentFolderTypeProvider)).length != 0) {
      return true;
    }
  }
  return false;
}
 

@Nullable
private Module getRootModule(ModifiableModelsProvider modelsProvider, ModulesProvider modulesProvider) {
  for(Module module:modulesProvider.getModules()) {
    ModifiableRootModel model = modelsProvider.getModuleModifiableModel(module);
    for(VirtualFile root:model.getContentRoots()) {
      if(root.getPath().equals(myProjectRoot)) {
        return module;
      }
    }
  }
  return null;
}
 

public ModuleWizardStep[] createWizardSteps(final WizardContext wizardContext,
                                            final HaxeModuleBuilder moduleBuilder,
                                            final ModulesProvider modulesProvider) {
  HaxeSdkType type = HaxeSdkType.getInstance();
  type.ensureSdk();

  return new ModuleWizardStep[]{
    new HaxeSdkWizardStep(moduleBuilder, wizardContext, type)
  };
}
 

@Override
public ModuleWizardStep[] createWizardSteps(@NotNull WizardContext wizardContext,
                                            @NotNull ModulesProvider modulesProvider) {
  return new ModuleWizardStep[]{new ModuleWizardStep() {
    @Override
    public JComponent getComponent() {
      return new JLabel("Put your content here");
    }

    @Override
    public void updateDataModel() {

    }
  }};
}
 

@NotNull
@Override
public ModuleWizardStep[] createWizardSteps(@NotNull WizardContext wizardContext,
                                            @NotNull DemoModuleBuilder moduleBuilder,
                                            @NotNull ModulesProvider modulesProvider) {
  return super.createWizardSteps(wizardContext, moduleBuilder, modulesProvider);
}
 

@Override
public ModuleWizardStep[] createWizardSteps(@NotNull WizardContext wizardContext, @NotNull ModulesProvider modulesProvider) {
    // It is not possible with IntelliJ to use the same Form with another class AFAIK
    // The original Select Properties Step is replaced by our own as we need to handle additional Properties from
    // archetype (required properties) and provide a Name field for convenience.
    return new ModuleWizardStep[]{
        new MavenModuleWizardStep(this, wizardContext, !wizardContext.isNewWizard()),
        new ArchetypePropertiesStep(wizardContext.getProject(), this)
    };
}
 

@Nullable
@Override
public List<Module> commit(
    Project project,
    @Nullable ModifiableModuleModel modifiableModuleModel,
    ModulesProvider modulesProvider) {
  builder.commitToProject(project);
  return ImmutableList.of();
}
 

@Override
public void setupFramework(@NotNull ModifiableModelsProvider modifiableModelsProvider, @NotNull ModulesProvider modulesProvider)
{
    ApplicationManager.getApplication().invokeLater(new Runnable() {
        @Override
        public void run() {
            final Module moduleForFile = ProjectRootManager.getInstance(context.getProject()).getFileIndex().getModuleForFile(collection.iterator().next());
            final AddSupportForSingleFrameworkDialog dialog = AddSupportForSingleFrameworkDialog.createDialog(moduleForFile, new MuleFrameworkSupportProvider());
            dialog.setTitle(dialog.getTitle() + " - " + moduleForFile.getName());
            dialog.showAndGet();
        }
    });
}
 

@Override
@Nonnull
public ModulesProvider getModulesProvider() {
  return new DefaultModulesProvider(myProject);
}
 

@Override
public ModuleWizardStep[] createWizardSteps(@NotNull WizardContext wizardContext, @NotNull ModulesProvider modulesProvider) {
    return new ModuleWizardStep[]{new QuarkusModuleInfoStep(wizardContext), new QuarkusExtensionsStep(wizardContext)};
}
 

@Override
public boolean isAvailableForAdd(@Nonnull ModulesProvider modulesProvider) {
  return ModuleUtil.hasModuleExtension(modulesProvider, SandModuleExtension.class);
}
 

@Override
@Nonnull
public ModulesProvider getModulesProvider() {
  return myContext.getModulesConfigurator();
}
 

@Override
@Nonnull
public ModulesProvider getModulesProvider() {
  return myParent.getModulesProvider();
}
 

@Override
public ModulesProvider getModulesProvider() {
  return myProvider;
}
 

public ModuleConfigurationStateImpl(@Nonnull Project project, @Nonnull ModulesProvider provider) {
  myProvider = provider;
  myProject = project;
}
 

@Override
public ModuleWizardStep[] createFinishingSteps(@NotNull WizardContext wizardContext, @NotNull ModulesProvider modulesProvider) {
    this.wizardContext = wizardContext;
    return super.createFinishingSteps(wizardContext, modulesProvider);
}
 

@Override
@Nonnull
public ModulesProvider getModulesProvider() {
  return myModulesProvider;
}
 

@Override
public ModuleWizardStep[] createWizardSteps(@NotNull WizardContext wizardContext, @NotNull ModulesProvider modulesProvider) {
    return new ModuleWizardStep[]{
            new DubboModuleWizardStep(this, wizardContext, !wizardContext.isNewWizard())
    };
}
 

public ModuleWizardStep[] createWizardSteps(@NotNull WizardContext wizardContext,
    @NotNull ModulesProvider modulesProvider) {
  return new ModuleWizardStep[] {new ProjectDetailsStep(this, wizardContext),
      new DependencySelectionStep(this)};
}