Java Code Examples for com.intellij.openapi.module.Module#getProject()

@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);
        }
    }
}
 

@Override
public void processImport(Module module) {
    Project project = module.getProject();
    VirtualFile pomFile = null;
    VirtualFile[] contentRoots = ModuleRootManager.getInstance(module).getContentRoots();
    for(VirtualFile contentRoot : contentRoots) {
        VirtualFile child = contentRoot.findChild("pom.xml");
        if (child != null) {
            pomFile = child;
            break;
        }
    }

    if (pomFile != null) {
        MavenProjectsManager mavenProjectsManager = MavenProjectsManager.getInstance(project);
        mavenProjectsManager.addManagedFiles(Collections.singletonList(pomFile));
    }
}
 

@Override
public boolean postProcess(Module module) {
  // TODO: Find a way to use GradleModuleBuilder instead of GradleProjectImportBuilder when adding a child module to the parent
  Project project = module.getProject();
  VirtualFile gradleFile = findFileUnderRootInModule(module, "build.gradle");
  if (gradleFile == null) { // not a gradle project
    return true;
  } else {
    ProjectDataManager projectDataManager = getService(ProjectDataManager.class);
    GradleProjectImportBuilder importBuilder = new GradleProjectImportBuilder(projectDataManager);
    GradleProjectImportProvider importProvider = new GradleProjectImportProvider(importBuilder);
    AddModuleWizard addModuleWizard =
        new AddModuleWizard(project, gradleFile.getPath(), importProvider);
    if (addModuleWizard.getStepCount() > 0 && !addModuleWizard
        .showAndGet()) { // user has cancelled import project prompt
      return true;
    } else { // user chose to import via the gradle import prompt
      importBuilder.commit(project, null, null);
      return false;
    }
  }
}
 

private void updateRootElementTextField() {
  final CreateTypedResourceFileAction action = getSelectedAction(myResourceTypeCombo);

  if (action != null) {
    final Module module = myFacet.getModule();
    final List<String> allowedTagNames = action.getSortedAllowedTagNames(myFacet);
    myRootElementField =
        new TextFieldWithAutoCompletion<>(
            module.getProject(),
            new StringsCompletionProvider(allowedTagNames, null),
            true,
            null);
    myRootElementField.setEnabled(allowedTagNames.size() > 1);
    myRootElementField.setText(action.isChooseTagName() ? "" : action.getDefaultRootTag(module));
    myRootElementFieldWrapper.removeAll();
    myRootElementFieldWrapper.add(myRootElementField, BorderLayout.CENTER);
    myRootElementLabel.setLabelFor(myRootElementField);
  }
}
 

@Override
public boolean postProcess(Module module) {
  // TODO: Find a way to use GradleModuleBuilder instead of GradleProjectImportBuilder when adding a child module to the parent
  Project project = module.getProject();
  VirtualFile pomFile = findFileUnderRootInModule(module, "pom.xml");
  if (pomFile == null) { // not a maven project
    return true;
  } else {
    MavenProjectsManager mavenProjectsManager = getInstance(project);
    mavenProjectsManager.addManagedFiles(singletonList(pomFile));
    return false;
  }
}
 

BlazeModuleSystem(Module module) {
  this.module = module;
  this.project = module.getProject();
  classFileFinder = BlazeClassFileFinderFactory.createBlazeClassFileFinder(module);
  sampleDataDirectoryProvider = new BlazeSampleDataDirectoryProvider(module);
  isWorkspaceModule = BlazeDataStorage.WORKSPACE_MODULE_NAME.equals(module.getName());
}
 

public static List<ValidationError> validateModule(@Nullable Module module) {
  List<ValidationError> errors = Lists.newArrayList();
  if (module == null) {
    errors.add(
        ValidationError.fatal(
            "No run configuration module found. Have you successfully synced your project?"));
    return errors;
  }
  final Project project = module.getProject();
  if (AndroidProjectInfo.getInstance(project).requiredAndroidModelMissing()) {
    errors.add(ValidationError.fatal(SYNC_FAILED_ERR_MSG));
  }
  return errors;
}
 

/**
 * The constructor
 *
 * @param module the dialog that allows analyzing dependencies
 */
protected AnalyzeDependenciesDialog(Module module) {
  super(module.getProject(), true);
  setTitle("Analyze Dependencies for " + module.getName());
  setModal(false);
  myComponent = new AnalyzeDependenciesComponent(module);
  Disposer.register(myDisposable, new Disposable() {
    @Override
    public void dispose() {
      myComponent.disposeUIResources();
    }
  });
  setOKButtonText("Close");
  init();
}
 

protected RailwaysSettingsDialog(@NotNull Module module) {
    super(module.getProject());

    setTitle("Configure Railways - module '" + module.getName() + "'");

    // Create panel and reset components
    myPanel = new RailwaysSettingsForm(module);
    myPanel.reset();

    // Important to call inherited init() method.
    init();
}
 

public static HaxeCommonCompilerUtil.CompilationContext createDummyCompilationContext(final Module module) {
  DummyCompileContext context = new DummyCompileContext() {
    @Override
    public Project getProject() {
      return module.getProject();
    }
  };
  return createCompilationContext(context, module, null);
}
 

public ModuleWithDependenciesAndLibsDependencies(final Module module) {
  super(module.getProject());
  myMainScope = GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module);
  final Map<Module, Collection<Module>> map = buildAllDependencies(module.getProject());
  if (map == null) return;
  final Collection<Module> modules = map.get(module);
  for (final Module dependency : modules) {
    myScopes.add(GlobalSearchScope.moduleWithLibrariesScope(dependency));
  }
}
 

public ModuleCompileScope(final Module module, boolean includeDependentModules) {
  myProject = module.getProject();
  myScopeModules = new HashSet<Module>();
  if (includeDependentModules) {
    buildScopeModulesSet(module);
  }
  else {
    myScopeModules.add(module);
  }
  myModules = ModuleManager.getInstance(myProject).getModules();
}
 

@Nonnull
public static LibrariesContainer createContainer(@Nonnull Module module) {
  return new LibrariesContainerImpl(module.getProject(), module, null);
}
 

public PsiBasedClassFileFinder(Module module) {
  this.module = module;
  project = module.getProject();
}
 

public BlazeCreateXmlResourcePanel(
    Module module,
    ResourceType resourceType,
    ResourceFolderType folderType,
    @Nullable String resourceName,
    @Nullable String resourceValue,
    boolean chooseName,
    boolean chooseValue,
    boolean chooseFilename,
    @Nullable VirtualFile defaultFile,
    @Nullable VirtualFile contextFile,
    Function<Module, IdeResourceNameValidator> nameValidatorFactory) {
  setupUi();
  setChangeNameVisible(false);
  setChangeValueVisible(false);
  setChangeFileNameVisible(chooseFilename);
  myModule = module;
  myContextFile = contextFile;
  if (chooseName) {
    setChangeNameVisible(true);
  }
  if (!StringUtil.isEmpty(resourceName)) {
    myNameField.setText(resourceName);
  }

  if (chooseValue) {
    setChangeValueVisible(true);
    if (!StringUtil.isEmpty(resourceValue)) {
      myValueField.setText(resourceValue);
    }
  }

  myResourceType = resourceType;

  ApplicationManager.getApplication().assertReadAccessAllowed();
  // Set up UI to choose the base directory if needed (use context to prune selection).
  myResDirLabel.setVisible(false);
  myResDirCombo.setVisible(false);
  myResDirCombo.addBrowseFolderListener(
      module.getProject(), FileChooserDescriptorFactory.createSingleFolderDescriptor());
  setupResourceDirectoryCombo();

  if (defaultFile == null) {
    final String defaultFileName =
        AndroidResourceUtilCompat.getDefaultResourceFileName(myResourceType);

    if (defaultFileName != null) {
      myFileNameCombo.getEditor().setItem(defaultFileName);
    }
  }

  myDirectoriesLabel.setLabelFor(myDirectoriesPanel);
  mySubdirPanel =
      new CreateXmlResourceSubdirPanel(module.getProject(), folderType, myDirectoriesPanel, this);
  myResourceNameValidator = nameValidatorFactory.apply(getModule());

  if (defaultFile != null) {
    resetFromFile(defaultFile, module.getProject());
  }
}
 

public ModuleLibrariesSearchScope(@Nonnull Module module) {
  super(module.getProject());
  myModule = module;
}
 

@Nonnull
public static LibrariesContainer createContainer(@Nonnull ModifiableRootModel rootModel) {
  Module module = rootModel.getModule();
  return new LibrariesContainerImpl(module.getProject(), module, rootModel);
}
 

public ModuleNode(Module module) {
  super(module.getProject());
  myModule = module;
}
 

public ModuleStructurePane(Module module) {
  super(module.getProject());
  myModule = module;
}
 

FileRecursiveIterator(@Nonnull Module module) {
  this(module.getProject(), ContainerUtil.<PsiDirectory, VirtualFile>map(collectModuleDirectories(module), psiDir -> psiDir.getVirtualFile()));
}