Java ModuleConfigurationState类代码示例

import com.intellij.openapi.roots.ui.configuration.ModuleConfigurationState; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public ModuleConfigurationEditor[] createEditors(final ModuleConfigurationState state) {
    final Module module = state.getRootModel().getModule();
    final ModuleType moduleType = ModuleType.get(module);
    if (moduleType != this.metaborgModuleType) {
        return ModuleConfigurationEditor.EMPTY;
    }

    final DefaultModuleConfigurationEditorFactory editorFactory
            = DefaultModuleConfigurationEditorFactory.getInstance();

    return new ModuleConfigurationEditor[]{
            editorFactory.createModuleContentRootsEditor(state),
            editorFactory.createOutputEditor(state),
            editorFactory.createClasspathEditor(state)
            // Add more editors here.
    };
}
 

import com.intellij.openapi.roots.ui.configuration.ModuleConfigurationState; //导入依赖的package包/类
@Override
public ModuleConfigurationEditor[] createEditors(ModuleConfigurationState state) {
    final Module module = state.getRootModel().getModule();
    final ModuleType moduleType = ModuleType.get(module);
    if (!(moduleType instanceof NimModuleType)) {
        return ModuleConfigurationEditor.EMPTY;
    }

    final DefaultModuleConfigurationEditorFactory editorFactory = DefaultModuleConfigurationEditorFactory.getInstance();
    return new ModuleConfigurationEditor[] {
            new NimModuleTypeEditor(state),
            //editorFactory.createModuleContentRootsEditor(state),
            //editorFactory.createOutputEditor(state),
            editorFactory.createClasspathEditor(state)
    };
}
 

import com.intellij.openapi.roots.ui.configuration.ModuleConfigurationState; //导入依赖的package包/类
@Override
public ModuleConfigurationEditor[] createEditors(ModuleConfigurationState state) {
    final Module module = state.getRootModel().getModule();

    final ModuleType moduleType = ModuleType.get(module);

    if (!(moduleType instanceof GaugeModuleType)) {
        return ModuleConfigurationEditor.EMPTY;
    }

    final DefaultModuleConfigurationEditorFactory editorFactory = DefaultModuleConfigurationEditorFactory.getInstance();
    List<ModuleConfigurationEditor> editors = new ArrayList<>();
    editors.add(editorFactory.createModuleContentRootsEditor(state));
    editors.add(editorFactory.createOutputEditor(state));
    editors.add(editorFactory.createClasspathEditor(state));
    return editors.toArray(new ModuleConfigurationEditor[editors.size()]);
}
 

import com.intellij.openapi.roots.ui.configuration.ModuleConfigurationState; //导入依赖的package包/类
@Override
public ModuleConfigurationEditor[] createEditors(ModuleConfigurationState moduleConfigurationState) {
    final Module module = moduleConfigurationState.getRootModel().getModule();
    if (ModuleType.get(module) != DojoToolkitModuleType.getInstance()) return ModuleConfigurationEditor.EMPTY;

    final DefaultModuleConfigurationEditorFactory editorFactory = DefaultModuleConfigurationEditorFactory.getInstance();
    List<ModuleConfigurationEditor> editors = new ArrayList<ModuleConfigurationEditor>();
    //editors.add(editorFactory.createModuleContentRootsEditor(moduleConfigurationState));

    for(Module theModule : ModuleManager.getInstance(moduleConfigurationState.getProject()).getModules())
    {
        ModuleType theType = ModuleType.get(theModule);

        int i=0;
    }

    return editors.toArray(new ModuleConfigurationEditor[editors.size()]);
}
 

import com.intellij.openapi.roots.ui.configuration.ModuleConfigurationState; //导入依赖的package包/类
public ModuleConfigurationEditor[] createEditors(@NotNull final ModuleConfigurationState state) {
    final Module module = state.getRootModel().getModule();
    if (!LuaModuleUtil.isLuaModule(module)) return ModuleConfigurationEditor.EMPTY;
    final DefaultModuleConfigurationEditorFactory editorFactory = DefaultModuleConfigurationEditorFactory.getInstance();
    final List<ModuleConfigurationEditor> editors = new ArrayList<ModuleConfigurationEditor>();

    editors.add(editorFactory.createModuleContentRootsEditor(state));
    editors.add(editorFactory.createClasspathEditor(state));

    return editors.toArray(new ModuleConfigurationEditor[editors.size()]);
}
 

import com.intellij.openapi.roots.ui.configuration.ModuleConfigurationState; //导入依赖的package包/类
protected FacetEditorContext createContext(final @NotNull Facet facet, final @Nullable FacetEditorContext parentContext) {
  Module module = facet.getModule();
  ModulesConfigurator modulesConfigurator = myContext.getModulesConfigurator();
  ModuleEditor moduleEditor = modulesConfigurator.getModuleEditor(module);
  if (moduleEditor == null) {
    LOG.error("ModuleEditor[" + module.getName() + "]==null: disposed = " + module.isDisposed() + ", is in model = "
              + Arrays.asList(modulesConfigurator.getModules()).contains(module));
  }

  final ModuleConfigurationState state = moduleEditor.createModuleConfigurationState();
  return new MyProjectConfigurableContext(facet, parentContext, state);
}
 

import com.intellij.openapi.roots.ui.configuration.ModuleConfigurationState; //导入依赖的package包/类
public ProjectConfigurableContext(final @NotNull Facet facet, final boolean isNewFacet,
                                  @Nullable FacetEditorContext parentContext,
                                  final ModuleConfigurationState state, final UserDataHolder sharedModuleData,
                                  final UserDataHolder sharedProjectData) {
  super(facet, parentContext, state.getFacetsProvider(), state.getModulesProvider(), sharedModuleData, sharedProjectData);
  myModuleConfigurationState = state;
  myNewFacet = isNewFacet;
  myModule = facet.getModule();
}
 

import com.intellij.openapi.roots.ui.configuration.ModuleConfigurationState; //导入依赖的package包/类
@Override
public ModuleConfigurationEditor[] createEditors(final ModuleConfigurationState state) {
  Module module = state.getRootModel().getModule();
  if (!WebModuleTypeBase.isWebModule(module)) {
    return ModuleConfigurationEditor.EMPTY;
  }
  return new ModuleConfigurationEditor[]{new CommonContentEntriesEditor(module.getName(), state)};
}
 

import com.intellij.openapi.roots.ui.configuration.ModuleConfigurationState; //导入依赖的package包/类
public ModuleConfigurationEditor[] createEditors(final ModuleConfigurationState state) {
  final Module module = state.getRootModel().getModule();
  if (!(ModuleType.get(module) instanceof PythonModuleType)) return ModuleConfigurationEditor.EMPTY;
  final DefaultModuleConfigurationEditorFactory editorFactory = DefaultModuleConfigurationEditorFactory.getInstance();
  final List<ModuleConfigurationEditor> editors = new ArrayList<ModuleConfigurationEditor>();
  editors.add(new PyContentEntriesEditor(module, state, JavaSourceRootType.SOURCE));
  editors.add(editorFactory.createClasspathEditor(state));
  return editors.toArray(new ModuleConfigurationEditor[editors.size()]);
}
 

import com.intellij.openapi.roots.ui.configuration.ModuleConfigurationState; //导入依赖的package包/类
public ModuleConfigurationEditor[] createEditors(ModuleConfigurationState state) {
  final Module module = state.getRootModel().getModule();
  if (ModuleType.get(module) != PluginModuleType.getInstance()) return ModuleConfigurationEditor.EMPTY;

  final DefaultModuleConfigurationEditorFactory editorFactory = DefaultModuleConfigurationEditorFactory.getInstance();
  List<ModuleConfigurationEditor> editors = new ArrayList<ModuleConfigurationEditor>();
  editors.add(editorFactory.createModuleContentRootsEditor(state));
  editors.add(editorFactory.createOutputEditor(state));
  editors.add(editorFactory.createClasspathEditor(state));
  editors.add(new PluginModuleBuildConfEditor(state));
  return editors.toArray(new ModuleConfigurationEditor[editors.size()]);
}
 

import com.intellij.openapi.roots.ui.configuration.ModuleConfigurationState; //导入依赖的package包/类
public ModuleConfigurationEditor[] createEditors(ModuleConfigurationState state) {
    final Module module = state.getRootModel().getModule();
    if (ModuleType.get(module) != DLangModuleType.getInstance()) {
        return ModuleConfigurationEditor.EMPTY;
    }

    final DefaultModuleConfigurationEditorFactory editorFactory = DefaultModuleConfigurationEditorFactory.getInstance();
    List<ModuleConfigurationEditor> editors = new ArrayList<ModuleConfigurationEditor>();
    editors.add(new CommonContentEntriesEditor(module.getName(), state, JavaSourceRootType.SOURCE, JavaSourceRootType.TEST_SOURCE));
    editors.add(new OutputElementsEditor(state));
    editors.add(editorFactory.createClasspathEditor(state));
    //editors.add(new DLangModuleBuildConfEditor(state)); //TODO: implement DLangModuleBuildConfEditor
    return editors.toArray(new ModuleConfigurationEditor[editors.size()]);
}
 

import com.intellij.openapi.roots.ui.configuration.ModuleConfigurationState; //导入依赖的package包/类
@Override
public ModuleConfigurationEditor[] createEditors(final ModuleConfigurationState state) {
    Module module = state.getRootModel().getModule();
    if (!AzureModuleType.isAzureModule(module)) {
        return ModuleConfigurationEditor.EMPTY;
    }
    return new ModuleConfigurationEditor[]{new ModuleEditor(state, new AzureModulePanel(state.getRootModel().getModule())),
            new ModuleEditor(state, new WARemoteAccessPanel(state.getRootModel().getModule(), false, null, null, null)),
            new ModuleEditor(state, new RolesPanel(state.getRootModel().getModule())),
            new ModuleEditor(state, new SubscriptionsPanel(state.getRootModel().getModule().getProject()))};
}
 

import com.intellij.openapi.roots.ui.configuration.ModuleConfigurationState; //导入依赖的package包/类
public ModuleConfigurationEditor[] createEditors(@NotNull final ModuleConfigurationState state) {
    final Module module = state.getRootModel().getModule();
    if (!OCamlModuleUtil.isOCamlModule(module)) return ModuleConfigurationEditor.EMPTY;
    final DefaultModuleConfigurationEditorFactory editorFactory = DefaultModuleConfigurationEditorFactory.getInstance();
    final List<ModuleConfigurationEditor> editors = new ArrayList<ModuleConfigurationEditor>();
    editors.add(editorFactory.createModuleContentRootsEditor(state));
    editors.add(editorFactory.createOutputEditor(state));
    editors.add(editorFactory.createClasspathEditor(state));
    return editors.toArray(new ModuleConfigurationEditor[editors.size()]);
}
 

import com.intellij.openapi.roots.ui.configuration.ModuleConfigurationState; //导入依赖的package包/类
public ModuleConfigurationEditor[] createEditors(ModuleConfigurationState state) {
    Module module = state.getRootModel().getModule();
    if (!(ModuleType.get(module) instanceof HaskellModuleType)) {
        return ModuleConfigurationEditor.EMPTY;
    }
    return new ModuleConfigurationEditor[]{
            new JavaContentEntriesEditor(module.getName(), state),
            // new CabalFilesEditor(state),
            new ClasspathEditor(state),
    };
}
 

import com.intellij.openapi.roots.ui.configuration.ModuleConfigurationState; //导入依赖的package包/类
@Override
public ModuleConfigurationEditor[] createEditors(final ModuleConfigurationState state) {
  Module module = state.getRootModel().getModule();
  if (!Comparing.equal(ModuleType.get(module).getId(), WebModuleTypeBase.WEB_MODULE)) {
    return ModuleConfigurationEditor.EMPTY;
  }
  return new ModuleConfigurationEditor[]{new CommonContentEntriesEditor(module.getName(), state, false, false)};
}